avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/util/aggregate-flags.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateFlags = aggregateFlags;
+const flags_1 = require("../flags");
+const json = (0, flags_1.boolean)({
+    description: 'Format output as json.',
+    helpGroup: 'GLOBAL',
+});
+function aggregateFlags(flags, baseFlags, enableJsonFlag) {
+    const combinedFlags = { ...baseFlags, ...flags };
+    return (enableJsonFlag ? { json, ...combinedFlags } : combinedFlags);
+}

data/payload/node_modules/@oclif/core/lib/util/cache-command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '../command';
+import { Plugin as IPlugin } from '../interfaces/plugin';
+export declare function cacheCommand(uncachedCmd: Command.Class, plugin?: IPlugin, respectNoCacheDefault?: boolean): Promise<Command.Cached>;

data/payload/node_modules/@oclif/core/lib/util/cache-command.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheCommand = cacheCommand;
+const aggregate_flags_1 = require("./aggregate-flags");
+const cache_default_value_1 = require("./cache-default-value");
+const ensure_arg_object_1 = require("./ensure-arg-object");
+const util_1 = require("./util");
+// In order to collect static properties up the inheritance chain, we need to recursively
+// access the prototypes until there's nothing left. This allows us to combine baseFlags
+// and flags as well as add in the json flag if enableJsonFlag is enabled.
+function mergePrototype(result, cmd) {
+    const proto = Object.getPrototypeOf(cmd);
+    const filteredProto = (0, util_1.pickBy)(proto, (v) => v !== undefined);
+    return Object.keys(proto).length > 0 ? mergePrototype({ ...filteredProto, ...result }, proto) : result;
+}
+async function cacheFlags(cmdFlags, respectNoCacheDefault) {
+    const promises = Object.entries(cmdFlags).map(async ([name, flag]) => [
+        name,
+        {
+            aliases: flag.aliases,
+            char: flag.char,
+            charAliases: flag.charAliases,
+            combinable: flag.combinable,
+            dependsOn: flag.dependsOn,
+            deprecateAliases: flag.deprecateAliases,
+            deprecated: flag.deprecated,
+            description: flag.description,
+            env: flag.env,
+            exclusive: flag.exclusive,
+            helpGroup: flag.helpGroup,
+            helpLabel: flag.helpLabel,
+            hidden: flag.hidden,
+            name,
+            noCacheDefault: flag.noCacheDefault,
+            relationships: flag.relationships,
+            required: flag.required,
+            summary: flag.summary,
+            ...(flag.type === 'boolean'
+                ? {
+                    allowNo: flag.allowNo,
+                    type: flag.type,
+                }
+                : {
+                    default: await (0, cache_default_value_1.cacheDefaultValue)(flag, respectNoCacheDefault),
+                    delimiter: flag.delimiter,
+                    hasDynamicHelp: typeof flag.defaultHelp === 'function',
+                    helpValue: flag.helpValue,
+                    multiple: flag.multiple,
+                    options: flag.options,
+                    type: flag.type,
+                }),
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheArgs(cmdArgs, respectNoCacheDefault) {
+    const promises = Object.entries(cmdArgs).map(async ([name, arg]) => [
+        name,
+        {
+            default: await (0, cache_default_value_1.cacheDefaultValue)(arg, respectNoCacheDefault),
+            description: arg.description,
+            hidden: arg.hidden,
+            multiple: arg.multiple,
+            name,
+            noCacheDefault: arg.noCacheDefault,
+            options: arg.options,
+            required: arg.required,
+        },
+    ]);
+    return Object.fromEntries(await Promise.all(promises));
+}
+async function cacheCommand(uncachedCmd, plugin, respectNoCacheDefault = false) {
+    const cmd = mergePrototype(uncachedCmd, uncachedCmd);
+    // @ts-expect-error because v2 commands have flags stored in _flags
+    const uncachedFlags = cmd.flags ?? cmd._flags;
+    // @ts-expect-error because v2 commands have base flags stored in _baseFlags
+    const uncachedBaseFlags = cmd.baseFlags ?? cmd._baseFlags;
+    const [flags, args] = await Promise.all([
+        cacheFlags((0, aggregate_flags_1.aggregateFlags)(uncachedFlags, uncachedBaseFlags, cmd.enableJsonFlag), respectNoCacheDefault),
+        cacheArgs((0, ensure_arg_object_1.ensureArgObject)(cmd.args), respectNoCacheDefault),
+    ]);
+    const stdProperties = {
+        // Replace all spaces in aliases with colons to standardize them.
+        aliases: (cmd.aliases ?? []).map((a) => a.replaceAll(' ', ':')),
+        args,
+        deprecateAliases: cmd.deprecateAliases,
+        deprecationOptions: cmd.deprecationOptions,
+        description: cmd.description,
+        // Support both `examples` and `example` for backwards compatibility.
+        examples: cmd.examples ?? cmd.example,
+        flags,
+        hasDynamicHelp: Object.values(flags).some((f) => f.hasDynamicHelp),
+        hidden: cmd.hidden,
+        hiddenAliases: cmd.hiddenAliases ?? [],
+        id: cmd.id,
+        pluginAlias: plugin && plugin.alias,
+        pluginName: plugin && plugin.name,
+        pluginType: plugin && plugin.type,
+        state: cmd.state,
+        strict: cmd.strict,
+        summary: cmd.summary,
+        usage: cmd.usage,
+    };
+    // do not include these properties in manifest
+    const ignoreCommandProperties = [
+        'plugin',
+        '_flags',
+        '_enableJsonFlag',
+        '_globalFlags',
+        '_baseFlags',
+        'baseFlags',
+        '_--',
+        '_base',
+    ];
+    // Add in any additional properties that are not standard command properties.
+    const stdKeysAndIgnored = new Set([...ignoreCommandProperties, ...Object.keys(stdProperties)]);
+    const keysToAdd = Object.keys(cmd).filter((property) => !stdKeysAndIgnored.has(property));
+    const additionalProperties = Object.fromEntries(keysToAdd.map((key) => [key, cmd[key]]));
+    return { ...stdProperties, ...additionalProperties };
+}

data/payload/node_modules/@oclif/core/lib/util/cache-default-value.d.ts

@@ -0,0 +1,2 @@
+import { Arg, OptionFlag } from '../interfaces/parser';
+export declare const cacheDefaultValue: (flagOrArg: Arg<any> | OptionFlag<any>, respectNoCacheDefault: boolean) => Promise<any>;

data/payload/node_modules/@oclif/core/lib/util/cache-default-value.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheDefaultValue = void 0;
+// when no manifest exists, the default is calculated.  This may throw, so we need to catch it
+const cacheDefaultValue = async (flagOrArg, respectNoCacheDefault) => {
+    if (respectNoCacheDefault && flagOrArg.noCacheDefault)
+        return;
+    // Prefer the defaultHelp function (returns a friendly string for complex types)
+    if (typeof flagOrArg.defaultHelp === 'function') {
+        try {
+            return await flagOrArg.defaultHelp({ flags: {}, options: flagOrArg });
+        }
+        catch {
+            return;
+        }
+    }
+    // if not specified, try the default function
+    if (typeof flagOrArg.default === 'function') {
+        try {
+            return await flagOrArg.default({ flags: {}, options: flagOrArg });
+        }
+        catch { }
+    }
+    else {
+        return flagOrArg.default;
+    }
+};
+exports.cacheDefaultValue = cacheDefaultValue;

data/payload/node_modules/@oclif/core/lib/util/determine-priority.d.ts

@@ -0,0 +1,18 @@
+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)
+ */
+export declare function determinePriority(plugins: string[], commands: Command.Loadable[]): Command.Loadable;

data/payload/node_modules/@oclif/core/lib/util/determine-priority.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determinePriority = determinePriority;
+/**
+ * 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)
+ */
+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];
+}

data/payload/node_modules/@oclif/core/lib/util/ensure-arg-object.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '../command';
+import { ArgInput } from '../interfaces/parser';
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+export declare function ensureArgObject(args?: {
+    [name: string]: Command.Arg.Cached;
+} | ArgInput | any[]): ArgInput;

data/payload/node_modules/@oclif/core/lib/util/ensure-arg-object.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureArgObject = ensureArgObject;
+/**
+ * Ensure that the provided args are an object. This is for backwards compatibility with v1 commands which
+ * defined args as an array.
+ *
+ * @param args Either an array of args or an object of args
+ * @returns ArgInput
+ */
+function ensureArgObject(args) {
+    return (Array.isArray(args) ? (args ?? []).reduce((x, y) => ({ ...x, [y.name]: y }), {}) : args ?? {});
+}

data/payload/node_modules/@oclif/core/lib/util/find-root.d.ts

@@ -0,0 +1,16 @@
+export declare function debug(...scope: string[]): (..._: any) => void;
+/**
+ * Returns the root directory of the plugin.
+ *
+ * It first attempts to use require.resolve to find the plugin root.
+ * If that returns a path, it will `cd` up the file system until if finds the package.json for the plugin
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ *
+ * If require.resolve throws an error, it will attempt to find the plugin root by traversing the file system.
+ * If we're in a PnP environment (determined by process.versions.pnp), it will use the pnpapi module to
+ * traverse the dependency tree. Otherwise, it will traverse the node_modules until it finds a package.json
+ * with a matching name.
+ *
+ * If no path is found, undefined is returned which will eventually result in a thrown Error from Plugin.
+ */
+export declare function findRoot(name: string | undefined, root: string): Promise<string | undefined>;

data/payload/node_modules/@oclif/core/lib/util/find-root.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = debug;
+exports.findRoot = findRoot;
+const node_path_1 = require("node:path");
+const logger_1 = require("../logger");
+const fs_1 = require("./fs");
+function debug(...scope) {
+    return (formatter, ...args) => (0, logger_1.getLogger)(['find-root', ...scope].join(':')).debug(formatter, ...args);
+}
+// essentially just "cd .."
+function* up(from) {
+    while ((0, node_path_1.dirname)(from) !== from) {
+        yield from;
+        from = (0, node_path_1.dirname)(from);
+    }
+    yield from;
+}
+/**
+ * Return the plugin root directory from a given file. This will `cd` up the file system until it finds
+ * a package.json and then return the dirname of that path.
+ *
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ */
+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(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(name)('Found root based on plugin name!');
+                return next;
+            }
+        }
+    }
+    // If there's no plugin name (typically just the root plugin), then we need
+    // to traverse the file system until we find a directory with a package.json
+    for (const next of up(root)) {
+        // Skip the bin directory
+        if ((0, node_path_1.basename)((0, node_path_1.dirname)(next)) === 'bin' &&
+            ['dev', 'dev.cmd', 'dev.js', 'run', 'run.cmd', 'run.js'].includes((0, node_path_1.basename)(next))) {
+            continue;
+        }
+        try {
+            const cur = (0, node_path_1.join)(next, 'package.json');
+            debug(name ?? 'root-plugin')(`Checking ${cur}`);
+            if (await (0, fs_1.safeReadJson)(cur)) {
+                debug(name ?? 'root-plugin')('Found root by traversing up from starting point!');
+                return (0, node_path_1.dirname)(cur);
+            }
+        }
+        catch { }
+    }
+}
+/**
+ * Find plugin root directory for plugins installed into node_modules that don't have a `main` or `export`.
+ * This will go up directories until it finds a directory with the plugin installed into it.
+ *
+ * See https://github.com/oclif/config/pull/289#issuecomment-983904051
+ */
+async function findRootLegacy(name, root) {
+    debug(name ?? 'root-plugin')('Finding root using legacy method');
+    for (const next of up(root)) {
+        let cur;
+        if (name) {
+            cur = (0, node_path_1.join)(next, 'node_modules', name, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+            const pkg = await (0, fs_1.safeReadJson)((0, node_path_1.join)(next, 'package.json'));
+            if (pkg?.name === name)
+                return next;
+        }
+        else {
+            cur = (0, node_path_1.join)(next, 'package.json');
+            if (await (0, fs_1.safeReadJson)(cur))
+                return (0, node_path_1.dirname)(cur);
+        }
+    }
+}
+let pnp;
+/**
+ * The pnpapi module is only available if running in a pnp environment. Because of that
+ * we have to require it from the plugin.
+ *
+ * Solution taken from here: https://github.com/yarnpkg/berry/issues/1467#issuecomment-642869600
+ */
+function maybeRequirePnpApi(root) {
+    if (pnp)
+        return pnp;
+    try {
+        // eslint-disable-next-line n/no-missing-require
+        pnp = require(require.resolve('pnpapi', { paths: [root] }));
+        return pnp;
+    }
+    catch { }
+}
+const getKey = (locator) => JSON.stringify(locator);
+const isPeerDependency = (pkg, parentPkg, name) => getKey(pkg?.packageDependencies.get(name)) === getKey(parentPkg?.packageDependencies.get(name));
+/**
+ * Traverse PnP dependency tree to find plugin root directory.
+ *
+ * Implementation adapted from https://yarnpkg.com/advanced/pnpapi#traversing-the-dependency-tree
+ */
+function findPnpRoot(name, root) {
+    maybeRequirePnpApi(root);
+    if (!pnp)
+        return;
+    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
+        const key = getKey(locator);
+        if (seen.has(key))
+            return;
+        const pkg = pnp.getPackageInformation(locator);
+        if (locator.name === name) {
+            return pkg.packageLocation;
+        }
+        seen.add(key);
+        for (const [name, referencish] of pkg.packageDependencies) {
+            // Unmet peer dependencies
+            if (referencish === null)
+                continue;
+            // Avoid iterating on peer dependencies - very expensive
+            if (parentPkg !== null && isPeerDependency(pkg, parentPkg, name))
+                continue;
+            const childLocator = pnp.getLocator(name, referencish);
+            const foundSomething = traverseDependencyTree(childLocator, pkg);
+            if (foundSomething)
+                return foundSomething;
+        }
+        // Important: This `delete` here causes the traversal to go over nodes even
+        // if they have already been traversed in another branch. If you don't need
+        // that, remove this line for a hefty speed increase.
+        seen.delete(key);
+    };
+    // Iterate on each workspace
+    for (const locator of pnp.getDependencyTreeRoots()) {
+        const foundSomething = traverseDependencyTree(locator);
+        if (foundSomething)
+            return foundSomething;
+    }
+}
+/**
+ * Returns the root directory of the plugin.
+ *
+ * It first attempts to use require.resolve to find the plugin root.
+ * If that returns a path, it will `cd` up the file system until if finds the package.json for the plugin
+ * Example: node_modules/@oclif/plugin-version/dist/index.js -> node_modules/@oclif/plugin-version
+ *
+ * If require.resolve throws an error, it will attempt to find the plugin root by traversing the file system.
+ * If we're in a PnP environment (determined by process.versions.pnp), it will use the pnpapi module to
+ * traverse the dependency tree. Otherwise, it will traverse the node_modules until it finds a package.json
+ * with a matching name.
+ *
+ * If no path is found, undefined is returned which will eventually result in a thrown Error from Plugin.
+ */
+async function findRoot(name, root) {
+    if (name) {
+        debug(name)(`Finding root using ${root}`);
+        let pkgPath;
+        try {
+            pkgPath = require.resolve(name, { paths: [root] });
+            debug(name)(`Found starting point with require.resolve`);
+        }
+        catch {
+            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(name)(`Found root at ${found}`);
+                return found;
+            }
+        }
+        const found = process.versions.pnp ? findPnpRoot(name, root) : await findRootLegacy(name, root);
+        debug(name)(found ? `Found root at ${found}` : 'No root found!');
+        return found;
+    }
+    debug('root-plugin')(`Finding root plugin using ${root}`);
+    const found = await findPluginRoot(root);
+    debug('root-plugin')(found ? `Found root at ${found}` : 'No root found!');
+    return found;
+}

data/payload/node_modules/@oclif/core/lib/util/fs.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Parser for Args.directory and Flags.directory. Checks that the provided path
+ * exists and is a directory.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
+export declare const dirExists: (input: string) => Promise<string>;
+/**
+ * Parser for Args.file and Flags.file. Checks that the provided path
+ * exists and is a file.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
+export declare const fileExists: (input: string) => Promise<string>;
+/**
+ * Read a file from disk and cache its contents if in production environment.
+ *
+ * Will throw an error if the file does not exist.
+ *
+ * @param path file path of JSON file
+ * @param useCache if false, ignore cache and read file from disk
+ * @returns <T>
+ */
+export declare function readJson<T = unknown>(path: string, useCache?: boolean): Promise<T>;
+/**
+ * Safely read a file from disk and cache its contents if in production environment.
+ *
+ * Will return undefined if the file does not exist.
+ *
+ * @param path file path of JSON file
+ * @param useCache if false, ignore cache and read file from disk
+ * @returns <T> or undefined
+ */
+export declare function safeReadJson<T>(path: string, useCache?: boolean): Promise<T | undefined>;
+export declare function existsSync(path: string): boolean;

data/payload/node_modules/@oclif/core/lib/util/fs.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileExists = exports.dirExists = void 0;
+exports.readJson = readJson;
+exports.safeReadJson = safeReadJson;
+exports.existsSync = existsSync;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const util_1 = require("./util");
+/**
+ * Parser for Args.directory and Flags.directory. Checks that the provided path
+ * exists and is a directory.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
+const dirExists = async (input) => {
+    let dirStat;
+    try {
+        dirStat = await (0, promises_1.stat)(input);
+    }
+    catch {
+        throw new Error(`No directory found at ${input}`);
+    }
+    if (!dirStat.isDirectory()) {
+        throw new Error(`${input} exists but is not a directory`);
+    }
+    return input;
+};
+exports.dirExists = dirExists;
+/**
+ * Parser for Args.file and Flags.file. Checks that the provided path
+ * exists and is a file.
+ * @param input flag or arg input
+ * @returns Promise<string>
+ */
+const fileExists = async (input) => {
+    let fileStat;
+    try {
+        fileStat = await (0, promises_1.stat)(input);
+    }
+    catch {
+        throw new Error(`No file found at ${input}`);
+    }
+    if (!fileStat.isFile()) {
+        throw new Error(`${input} exists but is not a file`);
+    }
+    return input;
+};
+exports.fileExists = fileExists;
+class ProdOnlyCache extends Map {
+    set(key, value) {
+        if ((0, util_1.isProd)() ?? false) {
+            super.set(key, value);
+        }
+        return this;
+    }
+}
+const cache = new ProdOnlyCache();
+/**
+ * Read a file from disk and cache its contents if in production environment.
+ *
+ * Will throw an error if the file does not exist.
+ *
+ * @param path file path of JSON file
+ * @param useCache if false, ignore cache and read file from disk
+ * @returns <T>
+ */
+async function readJson(path, useCache = true) {
+    if (useCache && 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);
+}
+/**
+ * Safely read a file from disk and cache its contents if in production environment.
+ *
+ * Will return undefined if the file does not exist.
+ *
+ * @param path file path of JSON file
+ * @param useCache if false, ignore cache and read file from disk
+ * @returns <T> or undefined
+ */
+async function safeReadJson(path, useCache = true) {
+    try {
+        return await readJson(path, useCache);
+    }
+    catch { }
+}
+function existsSync(path) {
+    return (0, node_fs_1.existsSync)(path);
+}

data/payload/node_modules/@oclif/core/lib/util/ids.d.ts

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

data/payload/node_modules/@oclif/core/lib/util/ids.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStandardizedId = toStandardizedId;
+exports.toConfiguredId = toConfiguredId;
+function toStandardizedId(commandID, config) {
+    return commandID.replaceAll(new RegExp(config.topicSeparator, 'g'), ':');
+}
+function toConfiguredId(commandID, config) {
+    const defaultTopicSeparator = ':';
+    return commandID.replaceAll(new RegExp(defaultTopicSeparator, 'g'), config.topicSeparator || defaultTopicSeparator);
+}

data/payload/node_modules/@oclif/core/lib/util/os.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Call os.homedir() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.homedir() is
+ * non-configurable and non-writable.
+ *
+ * @returns The user's home directory
+ */
+export declare function getHomeDir(): string;
+/**
+ * Call os.platform() and return the result
+ *
+ * Wrapping this allows us to stub these in tests since os.platform() is
+ * non-configurable and non-writable.
+ *
+ * @returns The process' platform
+ */
+export declare function getPlatform(): Promise<'wsl' | NodeJS.Platform>;
+export declare function getShell(): Promise<string>;