avo-cli 0.0.2 → 4.2.0.beta.1

data/payload/node_modules/@oclif/core/lib/help/root.d.ts

@@ -0,0 +1,11 @@
+import * as Interfaces from '../interfaces';
+import { HelpFormatter } from './formatter';
+export default class RootHelp extends HelpFormatter {
+    config: Interfaces.Config;
+    opts: Interfaces.HelpOptions;
+    constructor(config: Interfaces.Config, opts: Interfaces.HelpOptions);
+    protected description(): string | undefined;
+    root(): string;
+    protected usage(): string;
+    protected version(): string;
+}

data/payload/node_modules/@oclif/core/lib/help/root.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ansis_1 = __importDefault(require("ansis"));
+const util_1 = require("../util/util");
+const theme_1 = require("../ux/theme");
+const formatter_1 = require("./formatter");
+class RootHelp extends formatter_1.HelpFormatter {
+    config;
+    opts;
+    constructor(config, opts) {
+        super(config, opts);
+        this.config = config;
+        this.opts = opts;
+    }
+    description() {
+        let description = this.config.pjson.oclif.description || this.config.pjson.description || '';
+        description = this.render(description);
+        description = description.split('\n').slice(1).join('\n');
+        if (!description)
+            return;
+        return this.section('DESCRIPTION', this.wrap((0, theme_1.colorize)(this.config?.theme?.sectionDescription, description)));
+    }
+    root() {
+        let description = this.config.pjson.oclif.description || this.config.pjson.description || '';
+        description = this.render(description);
+        description = description.split('\n')[0];
+        let output = (0, util_1.compact)([
+            (0, theme_1.colorize)(this.config?.theme?.commandSummary, description),
+            this.version(),
+            this.usage(),
+            this.description(),
+        ]).join('\n\n');
+        if (this.opts.stripAnsi)
+            output = ansis_1.default.strip(output);
+        return output;
+    }
+    usage() {
+        return this.section(this.opts.usageHeader || 'USAGE', this.wrap(`${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${(0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin)} ${(0, theme_1.colorize)(this.config?.theme?.sectionDescription, '[COMMAND]')}`));
+    }
+    version() {
+        return this.section('VERSION', this.wrap((0, theme_1.colorize)(this.config?.theme?.version, this.config.userAgent)));
+    }
+}
+exports.default = RootHelp;

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

@@ -0,0 +1,7 @@
+import { Deprecation, Config as IConfig } from '../interfaces';
+export declare function template(context: any): (t: string) => string;
+export declare function standardizeIDFromArgv(argv: string[], config: IConfig): string[];
+export declare function getHelpFlagAdditions(config: IConfig): string[];
+export declare function formatFlagDeprecationWarning(flag: string, opts: Deprecation | true): string;
+export declare function formatCommandDeprecationWarning(command: string, opts?: Deprecation): string;
+export declare function normalizeArgv(config: IConfig, argv?: string[]): string[];

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

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.template = template;
+exports.standardizeIDFromArgv = standardizeIDFromArgv;
+exports.getHelpFlagAdditions = getHelpFlagAdditions;
+exports.formatFlagDeprecationWarning = formatFlagDeprecationWarning;
+exports.formatCommandDeprecationWarning = formatCommandDeprecationWarning;
+exports.normalizeArgv = normalizeArgv;
+const ejs_1 = __importDefault(require("ejs"));
+const util_1 = require("../config/util");
+const ids_1 = require("../util/ids");
+function template(context) {
+    function render(t) {
+        return ejs_1.default.render(t, context);
+    }
+    return render;
+}
+const isFlag = (s) => s.startsWith('-');
+const isArgWithValue = (s) => s.includes('=');
+function collateSpacedCmdIDFromArgs(argv, config) {
+    if (argv.length === 1)
+        return argv;
+    const findId = (argv) => {
+        const ids = (0, util_1.collectUsableIds)(config.commandIDs);
+        const final = [];
+        const idPresent = (id) => ids.has(id);
+        const finalizeId = (s) => (s ? [...final, s] : final).filter(Boolean).join(':');
+        const hasArgs = () => {
+            const id = finalizeId();
+            if (!id)
+                return false;
+            const cmd = config.findCommand(id);
+            return Boolean(cmd && (cmd.strict === false || Object.keys(cmd.args ?? {}).length > 0));
+        };
+        for (const arg of argv) {
+            if (idPresent(finalizeId(arg)))
+                final.push(arg);
+            // If the parent topic has a command that expects positional arguments, then we cannot
+            // assume that any subsequent string could be part of the command name
+            else if (isArgWithValue(arg) || isFlag(arg) || hasArgs())
+                break;
+            else
+                final.push(arg);
+        }
+        return finalizeId();
+    };
+    const id = findId(argv);
+    if (id) {
+        const argvSlice = argv.slice(id.split(':').length);
+        return [id, ...argvSlice];
+    }
+    return argv; // ID is argv[0]
+}
+function standardizeIDFromArgv(argv, config) {
+    if (argv.length === 0)
+        return argv;
+    if (config.topicSeparator === ' ')
+        argv = collateSpacedCmdIDFromArgs(argv, config);
+    else if (config.topicSeparator !== ':')
+        argv[0] = (0, ids_1.toStandardizedId)(argv[0], config);
+    return argv;
+}
+function getHelpFlagAdditions(config) {
+    const helpFlags = ['--help'];
+    const additionalHelpFlags = config.pjson.oclif.additionalHelpFlags ?? [];
+    return [...new Set([...additionalHelpFlags, ...helpFlags]).values()];
+}
+function formatFlagDeprecationWarning(flag, opts) {
+    let message = `The "${flag}" flag has been deprecated`;
+    if (opts === true)
+        return `${message}.`;
+    if (opts.message)
+        return opts.message;
+    if (opts.version) {
+        message += ` and will be removed in version ${opts.version}`;
+    }
+    message += opts.to ? `. Use "${opts.to}" instead.` : '.';
+    return message;
+}
+function formatCommandDeprecationWarning(command, opts) {
+    let message = `The "${command}" command has been deprecated`;
+    if (!opts)
+        return `${message}.`;
+    if (opts.message)
+        return opts.message;
+    if (opts.version) {
+        message += ` and will be removed in version ${opts.version}`;
+    }
+    message += opts.to ? `. Use "${opts.to}" instead.` : '.';
+    return message;
+}
+function normalizeArgv(config, argv = process.argv.slice(2)) {
+    if (config.topicSeparator !== ':' && !argv[0]?.includes(':'))
+        argv = standardizeIDFromArgv(argv, config);
+    return argv;
+}

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

@@ -0,0 +1,20 @@
+export * as Args from './args';
+export { Command } from './command';
+export { Config, Plugin } from './config';
+export * as Constraints from './constraints';
+export * as Errors from './errors';
+export { handle } from './errors/handle';
+export { execute } from './execute';
+export * as Flags from './flags';
+export { flush } from './flush';
+export { CommandHelp, Help, HelpBase, type HelpSection, type HelpSectionKeyValueTable, type HelpSectionRenderer, loadHelpClass, } from './help';
+export * as Interfaces from './interfaces';
+export { type Hook } from './interfaces/hooks';
+export { getLogger } from './logger';
+export { run } from './main';
+export * as ModuleLoader from './module-loader';
+export * as Parser from './parser';
+export { Performance } from './performance';
+export { type Settings, settings } from './settings';
+export { toConfiguredId, toStandardizedId } from './util/ids';
+export { ux } from './ux';

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

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ux = exports.toStandardizedId = exports.toConfiguredId = exports.settings = exports.Performance = exports.Parser = exports.ModuleLoader = exports.getLogger = exports.Interfaces = exports.loadHelpClass = exports.HelpBase = exports.Help = exports.CommandHelp = exports.flush = exports.Flags = exports.execute = exports.handle = exports.Errors = exports.Constraints = exports.Plugin = exports.Config = exports.Command = exports.Args = void 0;
+const util_1 = require("./util/util");
+function checkCWD() {
+    try {
+        process.cwd();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            process.stderr.write('WARNING: current directory does not exist\n');
+        }
+    }
+}
+function checkNodeVersion() {
+    if (process.env.OCLIF_DISABLE_ENGINE_WARNING && (0, util_1.isTruthy)(process.env.OCLIF_DISABLE_ENGINE_WARNING))
+        return;
+    try {
+        const path = require('node:path');
+        const semver = require('semver');
+        const root = path.join(__dirname, '..');
+        const pjson = require(path.join(root, 'package.json'));
+        if (!semver.satisfies(process.versions.node, pjson.engines.node)) {
+            process.emitWarning(`Node version must be ${pjson.engines.node} to use this CLI. Current node version: ${process.versions.node}`);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+checkCWD();
+checkNodeVersion();
+exports.Args = __importStar(require("./args"));
+var command_1 = require("./command");
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+Object.defineProperty(exports, "Plugin", { enumerable: true, get: function () { return config_1.Plugin; } });
+exports.Constraints = __importStar(require("./constraints"));
+exports.Errors = __importStar(require("./errors"));
+var handle_1 = require("./errors/handle");
+Object.defineProperty(exports, "handle", { enumerable: true, get: function () { return handle_1.handle; } });
+var execute_1 = require("./execute");
+Object.defineProperty(exports, "execute", { enumerable: true, get: function () { return execute_1.execute; } });
+exports.Flags = __importStar(require("./flags"));
+var flush_1 = require("./flush");
+Object.defineProperty(exports, "flush", { enumerable: true, get: function () { return flush_1.flush; } });
+var help_1 = require("./help");
+Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return help_1.CommandHelp; } });
+Object.defineProperty(exports, "Help", { enumerable: true, get: function () { return help_1.Help; } });
+Object.defineProperty(exports, "HelpBase", { enumerable: true, get: function () { return help_1.HelpBase; } });
+Object.defineProperty(exports, "loadHelpClass", { enumerable: true, get: function () { return help_1.loadHelpClass; } });
+exports.Interfaces = __importStar(require("./interfaces"));
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return logger_1.getLogger; } });
+var main_1 = require("./main");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return main_1.run; } });
+exports.ModuleLoader = __importStar(require("./module-loader"));
+exports.Parser = __importStar(require("./parser"));
+var performance_1 = require("./performance");
+Object.defineProperty(exports, "Performance", { enumerable: true, get: function () { return performance_1.Performance; } });
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "settings", { enumerable: true, get: function () { return settings_1.settings; } });
+var ids_1 = require("./util/ids");
+Object.defineProperty(exports, "toConfiguredId", { enumerable: true, get: function () { return ids_1.toConfiguredId; } });
+Object.defineProperty(exports, "toStandardizedId", { enumerable: true, get: function () { return ids_1.toStandardizedId; } });
+var ux_1 = require("./ux");
+Object.defineProperty(exports, "ux", { enumerable: true, get: function () { return ux_1.ux; } });

data/payload/node_modules/@oclif/core/lib/interfaces/alphabet.d.ts

@@ -0,0 +1,2 @@
+export type AlphabetUppercase = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+export type AlphabetLowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';

data/payload/node_modules/@oclif/core/lib/interfaces/alphabet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/args.d.ts

@@ -0,0 +1,22 @@
+import { ArgInput } from './parser';
+/**
+ * Infer the args that are returned by Command.parse. This is useful for when you want to assign the args as a class property.
+ *
+ * @example
+ * export type StatusArgs = Interfaces.InferredArgs<typeof Status.args>
+ *
+ * export default class Status {
+ *   static args = {
+ *     force: Args.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public args!: StatusArgs
+ *
+ *   public async run(): Promise<StatusArgs> {
+ *     const result = await this.parse(Status)
+ *     this.args = result.args
+ *     return result.args
+ *   }
+ * }
+ */
+export type InferredArgs<T> = T extends ArgInput<infer F> ? F : unknown;

data/payload/node_modules/@oclif/core/lib/interfaces/args.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,139 @@
+import { Command } from '../command';
+import { Hook, Hooks } from './hooks';
+import { OclifConfiguration, PJSON, S3Templates } from './pjson';
+import { Options, Plugin } from './plugin';
+import { Theme } from './theme';
+import { Topic } from './topic';
+export type LoadOptions = Config | Options | string | undefined;
+export type PlatformTypes = 'wsl' | NodeJS.Platform;
+export type ArchTypes = 'arm' | 'arm64' | 'mips' | 'mipsel' | 'ppc' | 'ppc64' | 's390' | 's390x' | 'x32' | 'x64' | 'x86';
+export type PluginVersionDetail = {
+    root: string;
+    type: string;
+    version: string;
+};
+export type VersionDetails = {
+    architecture: string;
+    cliVersion: string;
+    nodeVersion: string;
+    osVersion?: string;
+    pluginVersions?: Record<string, PluginVersionDetail>;
+    rootPath?: string;
+    shell?: string;
+};
+export interface Config {
+    /**
+     * process.arch
+     */
+    readonly arch: ArchTypes;
+    /**
+     * bin name of CLI command
+     */
+    readonly bin: string;
+    /**
+     * name of any bin aliases that will execute the cli
+     */
+    readonly binAliases?: string[] | undefined;
+    readonly binPath?: string | undefined;
+    /**
+     * cache directory to use for CLI
+     *
+     * example ~/Library/Caches/mycli or ~/.cache/mycli
+     */
+    readonly cacheDir: string;
+    readonly channel: string;
+    readonly commandIDs: string[];
+    readonly commands: Command.Loadable[];
+    /**
+     * config directory to use for CLI
+     *
+     * example: ~/.config/mycli
+     */
+    readonly configDir: string;
+    /**
+     * data directory to use for CLI
+     *
+     * example: ~/.local/share/mycli
+     */
+    readonly dataDir: string;
+    /**
+     * base dirname to use in cacheDir/configDir/dataDir
+     */
+    readonly dirname: string;
+    findCommand(id: string, opts: {
+        must: true;
+    }): Command.Loadable;
+    findCommand(id: string, opts?: {
+        must: boolean;
+    }): Command.Loadable | undefined;
+    findMatches(id: string, argv: string[]): Command.Loadable[];
+    findTopic(id: string, opts: {
+        must: true;
+    }): Topic;
+    findTopic(id: string, opts?: {
+        must: boolean;
+    }): Topic | undefined;
+    readonly flexibleTaxonomy?: boolean;
+    getAllCommandIDs(): string[];
+    getAllCommands(): Command.Loadable[];
+    getPluginsList(): Plugin[];
+    /**
+     * path to home directory
+     *
+     * example: /home/myuser
+     */
+    readonly home: string;
+    readonly isSingleCommandCLI: boolean;
+    readonly name: string;
+    /**
+     * npm registry to use for installing plugins
+     */
+    readonly npmRegistry?: string | undefined;
+    readonly nsisCustomization?: string | undefined;
+    readonly pjson: PJSON;
+    /**
+     * process.platform
+     */
+    readonly platform: PlatformTypes;
+    readonly plugins: Map<string, Plugin>;
+    readonly root: string;
+    runCommand<T = unknown>(id: string, argv?: string[], cachedCommand?: Command.Loadable): Promise<T>;
+    runHook<T extends keyof Hooks>(event: T, opts: Hooks[T]['options'], timeout?: number, captureErrors?: boolean): Promise<Hook.Result<Hooks[T]['return']>>;
+    s3Key(type: 'unversioned' | 'versioned', ext: '.tar.gz' | '.tar.xz', options?: Config.s3Key.Options): string;
+    s3Key(type: keyof S3Templates, options?: Config.s3Key.Options): string;
+    s3Url(key: string): string;
+    scopedEnvVar(key: string): string | undefined;
+    scopedEnvVarKey(key: string): string;
+    scopedEnvVarKeys(key: string): string[];
+    scopedEnvVarTrue(key: string): boolean;
+    /**
+     * active shell
+     */
+    readonly shell: string;
+    readonly theme?: Theme | undefined;
+    readonly topics: Topic[];
+    topicSeparator: ' ' | ':';
+    readonly updateConfig: NonNullable<OclifConfiguration['update']>;
+    /**
+     * user agent to use for http calls
+     *
+     * example: mycli/1.2.3 (darwin-x64) node-9.0.0
+     */
+    readonly userAgent: string;
+    readonly valid: boolean;
+    readonly version: string;
+    readonly versionDetails: VersionDetails;
+    /**
+     * if windows
+     */
+    readonly windows: boolean;
+}
+export declare namespace Config {
+    namespace s3Key {
+        interface Options {
+            [key: string]: any;
+            arch?: ArchTypes;
+            platform?: PlatformTypes;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/errors.d.ts

@@ -0,0 +1,27 @@
+export type CommandError = Error & {
+    exitCode?: number;
+};
+export interface OclifError {
+    oclif: {
+        exit?: number | undefined;
+    };
+}
+export interface PrettyPrintableError {
+    /**
+     * a unique error code for this error class
+     */
+    code?: string | undefined;
+    /**
+     * message to display related to the error
+     */
+    message?: string | undefined;
+    /**
+     * a url to find out more information related to this error
+     * or fixing the error
+     */
+    ref?: string | undefined;
+    /**
+     * a suggestion that may be useful or provide additional context
+     */
+    suggestions?: string[] | undefined;
+}

data/payload/node_modules/@oclif/core/lib/interfaces/errors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/flags.d.ts

@@ -0,0 +1,34 @@
+import { FlagInput } from './parser';
+/**
+ * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
+ *
+ * @example
+ * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags && typeof Status.baseFlags>
+ *
+ * export abstract class BaseCommand extends Command {
+ *   static enableJsonFlag = true
+ *
+ *   static flags = {
+ *     config: Flags.string({
+ *       description: 'specify config file',
+ *     }),
+ *   }
+ * }
+ *
+ * export default class Status extends BaseCommand {
+ *   static flags = {
+ *     force: Flags.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public flags!: StatusFlags
+ *
+ *   public async run(): Promise<StatusFlags> {
+ *     const result = await this.parse(Status)
+ *     this.flags = result.flags
+ *     return result.flags
+ *   }
+ * }
+ */
+export type InferredFlags<T> = T extends FlagInput<infer F> ? F & {
+    json: boolean | undefined;
+} : unknown;

data/payload/node_modules/@oclif/core/lib/interfaces/flags.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/payload/node_modules/@oclif/core/lib/interfaces/help.d.ts

@@ -0,0 +1,58 @@
+export interface HelpOptions {
+    all?: boolean;
+    /**
+     * Use docopts as the usage. Defaults to true.
+     */
+    docopts?: boolean;
+    /**
+     * Order in which to sort flags in help output. Defaults to `alphabetical`.
+     *
+     * `alphabetical`: Sort flags alphabetically. All flags with short characters will come first.
+     * `none`: Do not sort flags. They will appear in the order in which they were defined on the command.
+     */
+    flagSortOrder?: 'alphabetical' | 'none';
+    /**
+     * If true, hide command aliases from the root help output. Defaults to false.
+     */
+    hideAliasesFromRoot?: boolean;
+    /**
+     * By default, the command summary is show at the top of the help and as the first line in
+     * the command description. Repeating the summary in the command description improves readability
+     * especially for long command help output. If there is no `command.summary`, the first line of
+     * the description is treated as the summary. Some CLIs, especially with very simple commands, may
+     * not want the duplication.
+     */
+    hideCommandSummaryInDescription?: boolean;
+    maxWidth: number;
+    /**
+     * Respect the `noCacheDefault` property on flags. Defaults to false.
+     */
+    respectNoCacheDefault?: boolean;
+    /**
+     * Only show the help for the specified sections. Defaults to all sections.
+     */
+    sections?: string[];
+    /**
+     * By default, the help output is sent to stdout. If this is true, it will be sent to stderr.
+     */
+    sendToStderr?: boolean;
+    /**
+     * By default, titles show flag values as `<value>`. Some CLI developers may prefer titles
+     * to show the flag name as the value. i.e. `--myflag=myflag` instead of `--myflag=<value>`.
+     * An individual flag can set this using `flag.helpValue=flag.name`.
+     */
+    showFlagNameInTitle?: boolean;
+    /**
+     * By default, option values on flags are shown in the flag's description. This is because
+     * long options list ruin the formatting of help. If a CLI knows all commands will not
+     * do this, it can be turned off at a help level using this property. An individual flag
+     * can set this using `flag.helpValue=options.join('|')`.
+     */
+    showFlagOptionsInTitle?: boolean;
+    stripAnsi?: boolean;
+    /**
+     * Use USAGE, but some may want to use USAGE as used in gnu man pages. See help recommendations at
+     * http://www.gnu.org/software/help2man/#--help-recommendations
+     */
+    usageHeader?: string;
+}

data/payload/node_modules/@oclif/core/lib/interfaces/help.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });