avo-cli 0.0.2 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/config/index.d.ts

@@ -0,0 +1,3 @@
+export { Config } from './config';
+export { Plugin } from './plugin';
+export { tsPath } from './ts-path';

data/payload/node_modules/@oclif/core/lib/config/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsPath = exports.Plugin = exports.Config = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return plugin_1.Plugin; } });
+var ts_path_1 = require("./ts-path");
+Object.defineProperty(exports, "tsPath", { enumerable: true, get: function () { return ts_path_1.tsPath; } });

data/payload/node_modules/@oclif/core/lib/config/plugin-loader.d.ts

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

data/payload/node_modules/@oclif/core/lib/config/plugin-loader.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimatch_1 = require("minimatch");
+const node_path_1 = require("node:path");
+const performance_1 = require("../performance");
+const fs_1 = require("../util/fs");
+const util_1 = require("../util/util");
+const plugin_1 = require("./plugin");
+const util_2 = require("./util");
+const debug = (0, util_2.makeDebug)();
+function findMatchingDependencies(dependencies, patterns) {
+    return Object.keys(dependencies).filter((p) => patterns.some((w) => (0, minimatch_1.minimatch)(p, w)));
+}
+class PluginLoader {
+    options;
+    errors = [];
+    plugins = new Map();
+    pluginsProvided = false;
+    constructor(options) {
+        this.options = options;
+        if (options.plugins) {
+            this.pluginsProvided = true;
+            this.plugins = Array.isArray(options.plugins) ? new Map(options.plugins.map((p) => [p.name, p])) : options.plugins;
+        }
+    }
+    async loadChildren(opts) {
+        if (!this.pluginsProvided || opts.force) {
+            await this.loadUserPlugins(opts);
+            await this.loadDevPlugins(opts);
+            await this.loadCorePlugins(opts);
+        }
+        return { errors: this.errors, plugins: this.plugins };
+    }
+    async loadRoot({ pjson }) {
+        let rootPlugin;
+        if (this.pluginsProvided) {
+            const plugins = [...this.plugins.values()];
+            rootPlugin = plugins.find((p) => p.root === this.options.root) ?? plugins[0];
+        }
+        else {
+            const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, 'plugin.load#root');
+            rootPlugin = new plugin_1.Plugin({ isRoot: true, pjson, root: this.options.root });
+            await rootPlugin.load();
+            marker?.addDetails({
+                commandCount: rootPlugin.commands.length,
+                hasManifest: rootPlugin.hasManifest ?? false,
+                name: rootPlugin.name,
+                topicCount: rootPlugin.topics.length,
+                type: rootPlugin.type,
+                usesMain: Boolean(rootPlugin.pjson.main),
+            });
+            marker?.stop();
+        }
+        this.plugins.set(rootPlugin.name, rootPlugin);
+        return rootPlugin;
+    }
+    async loadCorePlugins(opts) {
+        const { plugins: corePlugins } = opts.rootPlugin.pjson.oclif;
+        if (corePlugins) {
+            const plugins = findMatchingDependencies(opts.rootPlugin.pjson.dependencies ?? {}, corePlugins);
+            await this.loadPlugins(opts.rootPlugin.root, 'core', plugins);
+        }
+        const { core: pluginAdditionsCore, path } = opts.pluginAdditions ?? { core: [] };
+        if (pluginAdditionsCore) {
+            if (path) {
+                // If path is provided, load plugins from the path
+                const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
+                const plugins = findMatchingDependencies(pjson.dependencies ?? {}, pluginAdditionsCore);
+                await this.loadPlugins(path, 'core', plugins);
+            }
+            else {
+                const plugins = findMatchingDependencies(opts.rootPlugin.pjson.dependencies ?? {}, pluginAdditionsCore);
+                await this.loadPlugins(opts.rootPlugin.root, 'core', plugins);
+            }
+        }
+    }
+    async loadDevPlugins(opts) {
+        if (opts.devPlugins !== false) {
+            // do not load oclif.devPlugins in production
+            if ((0, util_1.isProd)())
+                return;
+            try {
+                const { devPlugins } = opts.rootPlugin.pjson.oclif;
+                if (devPlugins) {
+                    const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
+                    const plugins = findMatchingDependencies(allDeps ?? {}, devPlugins);
+                    await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
+                }
+                const { dev: pluginAdditionsDev, path } = opts.pluginAdditions ?? { core: [] };
+                if (pluginAdditionsDev) {
+                    if (path) {
+                        // If path is provided, load plugins from the path
+                        const pjson = await (0, fs_1.readJson)((0, node_path_1.join)(path, 'package.json'));
+                        const allDeps = { ...pjson.dependencies, ...pjson.devDependencies };
+                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
+                        await this.loadPlugins(path, 'dev', plugins);
+                    }
+                    else {
+                        const allDeps = { ...opts.rootPlugin.pjson.dependencies, ...opts.rootPlugin.pjson.devDependencies };
+                        const plugins = findMatchingDependencies(allDeps ?? {}, pluginAdditionsDev);
+                        await this.loadPlugins(opts.rootPlugin.root, 'dev', plugins);
+                    }
+                }
+            }
+            catch (error) {
+                process.emitWarning(error);
+            }
+        }
+    }
+    async loadPlugins(root, type, plugins, parent) {
+        if (!plugins || plugins.length === 0)
+            return;
+        const mark = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `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,
+                    root,
+                    type,
+                };
+                if (typeof plugin !== 'string') {
+                    opts.tag = plugin.tag || opts.tag;
+                    opts.root = plugin.root || opts.root;
+                    opts.url = plugin.url;
+                }
+                if (parent) {
+                    opts.parent = parent;
+                }
+                if (this.plugins.has(name))
+                    return;
+                const pluginMarker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.load#${name}`);
+                const instance = new plugin_1.Plugin(opts);
+                await instance.load();
+                pluginMarker?.addDetails({
+                    commandCount: instance.commands.length,
+                    hasManifest: instance.hasManifest,
+                    name: instance.name,
+                    topicCount: instance.topics.length,
+                    type: instance.type,
+                    usesMain: Boolean(instance.pjson.main),
+                });
+                pluginMarker?.stop();
+                this.plugins.set(instance.name, instance);
+                if (parent) {
+                    instance.parent = parent;
+                    if (!parent.children)
+                        parent.children = [];
+                    parent.children.push(instance);
+                }
+                if (instance.pjson.oclif.plugins) {
+                    const allDeps = type === 'dev'
+                        ? { ...instance.pjson.dependencies, ...instance.pjson.devDependencies }
+                        : instance.pjson.dependencies;
+                    const plugins = findMatchingDependencies(allDeps ?? {}, instance.pjson.oclif.plugins);
+                    await this.loadPlugins(instance.root, type, plugins, instance);
+                }
+            }
+            catch (error) {
+                this.errors.push(error);
+            }
+        }));
+        mark?.addDetails({ pluginCount: plugins.length });
+        mark?.stop();
+    }
+    async loadUserPlugins(opts) {
+        if (opts.userPlugins !== false) {
+            try {
+                const userPJSONPath = (0, node_path_1.join)(opts.dataDir, 'package.json');
+                debug('reading user plugins pjson %s', userPJSONPath);
+                // ignore cache because the file might have changed within the same process (e.g. during a JIT plugin install)
+                const pjson = await (0, fs_1.readJson)(userPJSONPath, false);
+                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);
+            }
+        }
+    }
+}
+exports.default = PluginLoader;

data/payload/node_modules/@oclif/core/lib/config/plugin.d.ts

@@ -0,0 +1,51 @@
+import { Command } from '../command';
+import { Manifest } from '../interfaces/manifest';
+import { HookOptions, PJSON } from '../interfaces/pjson';
+import { Plugin as IPlugin, PluginOptions } from '../interfaces/plugin';
+import { Topic } from '../interfaces/topic';
+export declare class Plugin implements IPlugin {
+    options: PluginOptions;
+    _base: string;
+    protected _debug: (..._: any) => void;
+    alias: string;
+    alreadyLoaded: boolean;
+    children: Plugin[];
+    commandIDs: string[];
+    commands: Command.Loadable[];
+    commandsDir: string | undefined;
+    hasManifest: boolean;
+    hooks: {
+        [key: string]: HookOptions[];
+    };
+    isRoot: boolean;
+    manifest: Manifest;
+    moduleType: 'commonjs' | 'module';
+    name: string;
+    parent?: Plugin | undefined;
+    pjson: PJSON;
+    root: string;
+    tag?: string | undefined;
+    type: string;
+    valid: boolean;
+    version: string;
+    private commandCache;
+    private commandDiscoveryOpts;
+    private flexibleTaxonomy;
+    constructor(options: PluginOptions);
+    get topics(): Topic[];
+    findCommand(id: string, opts: {
+        must: true;
+    }): Promise<Command.Class>;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Promise<Command.Class | undefined>;
+    load(): Promise<void>;
+    private _manifest;
+    private addErrorScope;
+    private getCommandIDs;
+    private getCommandIdsFromPattern;
+    private getCommandIdsFromTarget;
+    private getCommandsDir;
+    private loadCommandsFromTarget;
+    private warn;
+}

data/payload/node_modules/@oclif/core/lib/config/plugin.js

@@ -0,0 +1,373 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const tinyglobby_1 = require("tinyglobby");
+const cache_1 = __importDefault(require("../cache"));
+const errors_1 = require("../errors");
+const module_loader_1 = require("../module-loader");
+const performance_1 = require("../performance");
+const symbols_1 = require("../symbols");
+const cache_command_1 = require("../util/cache-command");
+const find_root_1 = require("../util/find-root");
+const fs_1 = require("../util/fs");
+const read_pjson_1 = require("../util/read-pjson");
+const util_1 = require("../util/util");
+const ts_path_1 = require("./ts-path");
+const util_2 = require("./util");
+const _pjson = cache_1.default.getInstance().get('@oclif/core');
+function topicsToArray(input, base) {
+    if (!input)
+        return [];
+    base = base ? `${base}:` : '';
+    if (Array.isArray(input)) {
+        return [...input, input.flatMap((t) => topicsToArray(t.subtopics, `${base}${t.name}`))];
+    }
+    return Object.keys(input).flatMap((k) => {
+        input[k].name = k;
+        return [{ ...input[k], name: `${base}${k}` }, ...topicsToArray(input[k].subtopics, `${base}${input[k].name}`)];
+    });
+}
+const cachedCommandCanBeUsed = (manifest, id) => Boolean(manifest?.commands[id] && 'isESM' in manifest.commands[id] && 'relativePath' in manifest.commands[id]);
+const searchForCommandClass = (cmd) => {
+    if (typeof cmd.run === 'function')
+        return cmd;
+    if (cmd.default && cmd.default.run)
+        return cmd.default;
+    return Object.values(cmd).find((cmd) => typeof cmd.run === 'function');
+};
+const ensureCommandClass = (cmd) => {
+    if (cmd && typeof cmd.run === 'function')
+        return cmd;
+};
+const GLOB_PATTERNS = [
+    '**/*.+(js|cjs|mjs|ts|tsx|mts|cts)',
+    '!**/*.+(d.ts|test.ts|test.js|spec.ts|spec.js|d.mts|d.cts)?(x)',
+];
+function processCommandIds(files) {
+    return files.map((file) => {
+        const p = (0, node_path_1.parse)(file);
+        const topics = p.dir.split('/');
+        const command = p.name !== 'index' && p.name;
+        const id = [...topics, command].filter(Boolean).join(':');
+        return id === '' ? symbols_1.SINGLE_COMMAND_CLI_SYMBOL : id;
+    });
+}
+function determineCommandDiscoveryOptions(commandDiscovery) {
+    if (!commandDiscovery)
+        return;
+    if (typeof commandDiscovery === 'string') {
+        return { globPatterns: GLOB_PATTERNS, strategy: 'pattern', target: commandDiscovery };
+    }
+    if (!commandDiscovery.target)
+        throw new errors_1.CLIError('`oclif.commandDiscovery.target` is required.');
+    if (!commandDiscovery.strategy)
+        throw new errors_1.CLIError('`oclif.commandDiscovery.strategy` is required.');
+    if (commandDiscovery.strategy === 'explicit' && !commandDiscovery.identifier) {
+        commandDiscovery.identifier = 'default';
+    }
+    return commandDiscovery;
+}
+function determineHookOptions(hook) {
+    if (typeof hook === 'string')
+        return { identifier: 'default', target: hook };
+    if (!hook.identifier)
+        return { ...hook, identifier: 'default' };
+    return hook;
+}
+class Plugin {
+    options;
+    _base = `${_pjson.name}@${_pjson.version}`;
+    _debug = (0, util_2.makeDebug)();
+    alias;
+    alreadyLoaded = false;
+    children = [];
+    commandIDs = [];
+    // This will be initialized in the _manifest() method, which gets called in the load() method.
+    commands;
+    commandsDir;
+    hasManifest = false;
+    hooks;
+    isRoot = false;
+    manifest;
+    moduleType;
+    name;
+    parent;
+    pjson;
+    root;
+    tag;
+    type;
+    valid = false;
+    version;
+    commandCache;
+    commandDiscoveryOpts;
+    flexibleTaxonomy;
+    constructor(options) {
+        this.options = options;
+    }
+    get topics() {
+        return topicsToArray(this.pjson.oclif.topics || {});
+    }
+    async findCommand(id, opts = {}) {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.findCommand#${this.name}.${id}`, {
+            id,
+            plugin: this.name,
+        });
+        const fetch = async () => {
+            if (this.commandDiscoveryOpts?.strategy === 'pattern') {
+                const commandsDir = await this.getCommandsDir();
+                if (!commandsDir)
+                    return;
+                let module;
+                let isESM;
+                let filePath;
+                try {
+                    ;
+                    ({ filePath, isESM, module } = cachedCommandCanBeUsed(this.manifest, id)
+                        ? await (0, module_loader_1.loadWithDataFromManifest)(this.manifest.commands[id], this.root)
+                        : await (0, module_loader_1.loadWithData)(this, (0, node_path_1.join)(commandsDir ?? this.pjson.oclif.commands, ...id.split(':'))));
+                    this._debug(isESM ? '(import)' : '(require)', filePath);
+                }
+                catch (error) {
+                    if (!opts.must && error.code === 'MODULE_NOT_FOUND')
+                        return;
+                    throw error;
+                }
+                const cmd = searchForCommandClass(module);
+                if (!cmd)
+                    return;
+                cmd.id = id;
+                cmd.plugin = this;
+                cmd.isESM = isESM;
+                cmd.relativePath = (0, node_path_1.relative)(this.root, filePath || '').split(node_path_1.sep);
+                return cmd;
+            }
+            if (this.commandDiscoveryOpts?.strategy === 'single' || this.commandDiscoveryOpts?.strategy === 'explicit') {
+                const commandCache = await this.loadCommandsFromTarget();
+                const cmd = ensureCommandClass(commandCache?.[id]);
+                if (!cmd)
+                    return;
+                cmd.id = id;
+                cmd.plugin = this;
+                return cmd;
+            }
+        };
+        const cmd = await fetch();
+        if (!cmd && opts.must)
+            (0, errors_1.error)(`command ${id} not found`);
+        marker?.stop();
+        return cmd;
+    }
+    // eslint-disable-next-line complexity
+    async load() {
+        this.type = this.options.type ?? 'core';
+        this.tag = this.options.tag;
+        this.isRoot = this.options.isRoot ?? false;
+        if (this.options.parent)
+            this.parent = this.options.parent;
+        // Linked plugins already have a root so there's no need to search for it.
+        // However there could be child plugins nested inside the linked plugin, in which
+        // case we still need to search for the child plugin's root.
+        const root = this.options.pjson && this.options.isRoot
+            ? this.options.root
+            : this.type === 'link' && !this.parent
+                ? this.options.root
+                : await (0, find_root_1.findRoot)(this.options.name, this.options.root);
+        if (!root)
+            throw new errors_1.CLIError(`could not find package.json with ${(0, node_util_1.inspect)(this.options)}`);
+        this.root = root;
+        this._debug(`loading ${this.type} plugin from ${root}`);
+        this.pjson = this.options.pjson ?? (await (0, read_pjson_1.readPjson)(root));
+        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;
+        if (!this.name)
+            throw new errors_1.CLIError(`no name in package.json (${root})`);
+        this._debug = (0, util_2.makeDebug)(this.name);
+        this.version = this.pjson.version;
+        if (this.pjson.oclif) {
+            this.valid = true;
+        }
+        else {
+            this.pjson.oclif = this.pjson['cli-engine'] || {};
+        }
+        this.hooks = Object.fromEntries(Object.entries(this.pjson.oclif.hooks ?? {}).map(([k, v]) => [
+            k,
+            (0, util_1.castArray)(v).map((v) => determineHookOptions(v)),
+        ]));
+        this.commandDiscoveryOpts = determineCommandDiscoveryOptions(this.pjson.oclif?.commands);
+        this._debug('command discovery options', this.commandDiscoveryOpts);
+        this.manifest = await this._manifest();
+        this.commands = Object.entries(this.manifest.commands)
+            .map(([id, c]) => ({
+            ...c,
+            load: async () => this.findCommand(id, { must: true }),
+            pluginAlias: this.alias,
+            pluginType: c.pluginType === 'jit' ? 'jit' : this.type,
+        }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    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 = (0, node_path_1.join)(this.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
+                const manifest = await (0, fs_1.readJson)(p);
+                if (!process.env.OCLIF_NEXT_VERSION && manifest.version.split('-')[0] !== this.version.split('-')[0]) {
+                    process.emitWarning(`Mismatched version in ${this.name} plugin manifest. Expected: ${this.version} Received: ${manifest.version}\nThis usually means you have an oclif.manifest.json file that should be deleted in development. This file should be automatically generated when publishing.`);
+                }
+                else {
+                    this._debug('using manifest from', p);
+                    this.hasManifest = true;
+                    return manifest;
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    if (!dotfile)
+                        return readManifest(true);
+                }
+                else {
+                    this.warn(error, 'readManifest');
+                }
+            }
+        };
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.manifest#${this.name}`, { plugin: this.name });
+        if (!ignoreManifest) {
+            const manifest = await readManifest();
+            if (manifest) {
+                marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: true });
+                marker?.stop();
+                this.commandIDs = Object.keys(manifest.commands);
+                return manifest;
+            }
+        }
+        this.commandIDs = await this.getCommandIDs();
+        const manifest = {
+            commands: (await Promise.all(this.commandIDs.map(async (id) => {
+                try {
+                    const found = await this.findCommand(id, { must: true });
+                    const cached = await (0, cache_command_1.cacheCommand)(found, this, respectNoCacheDefault);
+                    // Ensure that id is set to the id being processed
+                    // This is necessary because the id is set by findCommand but if there
+                    // are multiple instances of a Command, then the id will be set to the
+                    // last one found.
+                    cached.id = id;
+                    if (this.flexibleTaxonomy) {
+                        const permutations = (0, util_2.getCommandIdPermutations)(id);
+                        const aliasPermutations = cached.aliases.flatMap((a) => (0, util_2.getCommandIdPermutations)(a));
+                        return [id, { ...cached, aliasPermutations, permutations }];
+                    }
+                    return [id, cached];
+                }
+                catch (error) {
+                    const scope = `findCommand (${id})`;
+                    if (Boolean(errorOnManifestCreate) === false)
+                        this.warn(error, scope);
+                    else
+                        throw this.addErrorScope(error, scope);
+                }
+            })))
+                .filter((f) => Boolean(f))
+                .reduce((commands, [id, c]) => {
+                commands[id] = c;
+                return commands;
+            }, {}),
+            version: this.version,
+        };
+        marker?.addDetails({ commandCount: Object.keys(manifest.commands).length, fromCache: false });
+        marker?.stop();
+        return manifest;
+    }
+    addErrorScope(err, scope) {
+        err.name = err.name ?? (0, node_util_1.inspect)(err).trim();
+        err.detail = (0, util_1.compact)([
+            err.detail,
+            `module: ${this._base}`,
+            scope && `task: ${scope}`,
+            `plugin: ${this.name}`,
+            `root: ${this.root}`,
+            ...(err.code ? [`code: ${err.code}`] : []),
+            ...(err.message ? [`message: ${err.message}`] : []),
+            'See more details with DEBUG=*',
+        ]).join('\n');
+        return err;
+    }
+    async getCommandIDs() {
+        const marker = performance_1.Performance.mark(performance_1.OCLIF_MARKER_OWNER, `plugin.getCommandIDs#${this.name}`, { plugin: this.name });
+        let ids;
+        switch (this.commandDiscoveryOpts?.strategy) {
+            case 'explicit': {
+                ids = (await this.getCommandIdsFromTarget()) ?? [];
+                break;
+            }
+            case 'pattern': {
+                ids = await this.getCommandIdsFromPattern();
+                break;
+            }
+            case 'single': {
+                ids = (await this.getCommandIdsFromTarget()) ?? [];
+                break;
+            }
+            default: {
+                ids = [];
+            }
+        }
+        this._debug('found commands', ids);
+        marker?.addDetails({ count: ids.length });
+        marker?.stop();
+        return ids;
+    }
+    async getCommandIdsFromPattern() {
+        const commandsDir = await this.getCommandsDir();
+        if (!commandsDir)
+            return [];
+        this._debug(`loading IDs from ${commandsDir}`);
+        const files = await (0, tinyglobby_1.glob)(this.commandDiscoveryOpts?.globPatterns ?? GLOB_PATTERNS, { cwd: commandsDir });
+        return processCommandIds(files);
+    }
+    async getCommandIdsFromTarget() {
+        const commandsFromExport = await this.loadCommandsFromTarget();
+        if (commandsFromExport) {
+            return Object.entries((await this.loadCommandsFromTarget()) ?? [])
+                .filter(([, cmd]) => ensureCommandClass(cmd))
+                .map(([id]) => id);
+        }
+    }
+    async getCommandsDir() {
+        if (this.commandsDir)
+            return this.commandsDir;
+        this.commandsDir = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts?.target, this);
+        return this.commandsDir;
+    }
+    async loadCommandsFromTarget() {
+        if (this.commandCache)
+            return this.commandCache;
+        if (this.commandDiscoveryOpts?.strategy === 'explicit' && this.commandDiscoveryOpts.target) {
+            const filePath = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts.target, this);
+            const module = await (0, module_loader_1.load)(this, filePath);
+            this.commandCache = module[this.commandDiscoveryOpts?.identifier ?? 'default'] ?? {};
+            return this.commandCache;
+        }
+        if (this.commandDiscoveryOpts?.strategy === 'single' && this.commandDiscoveryOpts.target) {
+            const filePath = await (0, ts_path_1.tsPath)(this.root, this.commandDiscoveryOpts?.target ?? this.root, this);
+            const module = await (0, module_loader_1.load)(this, filePath);
+            this.commandCache = { [symbols_1.SINGLE_COMMAND_CLI_SYMBOL]: searchForCommandClass(module) };
+            return this.commandCache;
+        }
+    }
+    warn(err, scope) {
+        if (typeof err === 'string')
+            err = new Error(err);
+        const warning = this.addErrorScope(err, scope);
+        process.emitWarning(warning.name, warning);
+    }
+}
+exports.Plugin = Plugin;

data/payload/node_modules/@oclif/core/lib/config/ts-path.d.ts

@@ -0,0 +1,9 @@
+import { Plugin, TSConfig } from '../interfaces';
+export declare const TS_CONFIGS: Record<string, TSConfig | undefined>;
+/**
+ * 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, plugin: Plugin): Promise<string>;
+export declare function tsPath(root: string, orig: string | undefined, plugin?: Plugin | undefined): Promise<string | undefined>;