avo-cli 0.0.2 → 4.2.0.beta.1

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

@@ -0,0 +1,96 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+export type HelpSectionKeyValueTable = {
+    description: string;
+    name: string;
+}[];
+export type HelpSection = {
+    body: [string, string | undefined][] | HelpSectionKeyValueTable | string | undefined;
+    header: string;
+} | undefined;
+export type HelpSectionRenderer = (data: {
+    args: Command.Arg.Any[];
+    cmd: Command.Loadable;
+    flags: Command.Flag.Any[];
+}, header: string) => HelpSection | HelpSection[] | string | undefined;
+export declare class HelpFormatter {
+    protected config: Interfaces.Config;
+    indentSpacing: number;
+    protected opts: Interfaces.HelpOptions;
+    /**
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
+     *
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
+     * ```
+     */
+    render: (input: string) => string;
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    /**
+     * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
+     *
+     * In order to call indent multiple times on the same set or text, the caller must wrap based on
+     * the number of times the text has been indented. For example.
+     *
+     * ```javascript
+     * const body = `main line\n${indent(wrap('indented example line', 4))}`
+     * const header = 'SECTION'
+     * console.log(`${header}\n${indent(wrap(body))}`
+     * ```
+     * will output
+     * ```
+     * SECTION
+     *   main line
+     *     indented example line
+     * ```
+     *
+     * If the terminal width was 24 and the `4` was not provided in the first wrap, it would like like the following.
+     * ```
+     * SECTION
+     *   main line
+     *     indented example
+     *   line
+     * ```
+     * @param body the text to indent
+     * @param spacing the final number of spaces this text will be indented
+     * @returns the formatted indented text
+     */
+    indent(body: string, spacing?: number): string;
+    renderList(input: (string | undefined)[][], opts: {
+        indentation: number;
+        multiline?: boolean | undefined;
+        spacer?: string | undefined;
+        stripAnsi?: boolean | undefined;
+    }): string;
+    section(header: string, body: [string, string | undefined][] | HelpSection | HelpSectionKeyValueTable | string): string;
+    /**
+     * Wrap text according to `opts.maxWidth` which is typically set to the terminal width. All text
+     * will be rendered before bring wrapped, otherwise it could mess up the lengths.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body: string, spacing?: number): string;
+}

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

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpFormatter = void 0;
+const ansis_1 = __importDefault(require("ansis"));
+const indent_string_1 = __importDefault(require("indent-string"));
+const string_width_1 = __importDefault(require("string-width"));
+const widest_line_1 = __importDefault(require("widest-line"));
+const wrap_ansi_1 = __importDefault(require("wrap-ansi"));
+const screen_1 = require("../screen");
+const theme_1 = require("../ux/theme");
+const util_1 = require("./util");
+class HelpFormatter {
+    config;
+    indentSpacing = 2;
+    opts;
+    /**
+     * Takes a string and replaces `<%= prop =>` with the value of prop, where prop is anything on
+     * `config=Interfaces.Config` or `opts=Interface.HelpOptions`.
+     *
+     * ```javascript
+     * `<%= config.bin =>` // will resolve to the bin defined in `pjson.oclif`.
+     * ```
+     */
+    render;
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.opts = { maxWidth: screen_1.stdtermwidth, ...opts };
+        this.render = (0, util_1.template)(this);
+    }
+    /**
+     * Indent by `this.indentSpacing`. The text should be wrap based on terminal width before indented.
+     *
+     * In order to call indent multiple times on the same set or text, the caller must wrap based on
+     * the number of times the text has been indented. For example.
+     *
+     * ```javascript
+     * const body = `main line\n${indent(wrap('indented example line', 4))}`
+     * const header = 'SECTION'
+     * console.log(`${header}\n${indent(wrap(body))}`
+     * ```
+     * will output
+     * ```
+     * SECTION
+     *   main line
+     *     indented example line
+     * ```
+     *
+     * If the terminal width was 24 and the `4` was not provided in the first wrap, it would like like the following.
+     * ```
+     * SECTION
+     *   main line
+     *     indented example
+     *   line
+     * ```
+     * @param body the text to indent
+     * @param spacing the final number of spaces this text will be indented
+     * @returns the formatted indented text
+     */
+    indent(body, spacing = this.indentSpacing) {
+        return (0, indent_string_1.default)(body, spacing);
+    }
+    renderList(input, opts) {
+        if (input.length === 0) {
+            return '';
+        }
+        const renderMultiline = () => {
+            let output = '';
+            for (let [left, right] of input) {
+                if (!left && !right)
+                    continue;
+                if (left) {
+                    if (opts.stripAnsi)
+                        left = ansis_1.default.strip(left);
+                    output += this.wrap(left.trim(), opts.indentation);
+                }
+                if (right) {
+                    if (opts.stripAnsi)
+                        right = ansis_1.default.strip(right);
+                    output += '\n';
+                    output += this.indent(this.wrap(right.trim(), opts.indentation + 2), 4);
+                }
+                output += '\n\n';
+            }
+            return output.trim();
+        };
+        if (opts.multiline)
+            return renderMultiline();
+        const maxLength = (0, widest_line_1.default)(input.map((i) => i[0]).join('\n'));
+        let output = '';
+        let spacer = opts.spacer || '\n';
+        let cur = '';
+        for (const [left, r] of input) {
+            let right = r;
+            if (cur) {
+                output += spacer;
+                output += cur;
+            }
+            cur = left || '';
+            if (opts.stripAnsi)
+                cur = ansis_1.default.strip(cur);
+            if (!right) {
+                cur = cur.trim();
+                continue;
+            }
+            if (opts.stripAnsi)
+                right = ansis_1.default.strip(right);
+            right = this.wrap(right.trim(), opts.indentation + maxLength + 2);
+            const [first, ...lines] = right.split('\n').map((s) => s.trim());
+            cur += ' '.repeat(maxLength - (0, string_width_1.default)(cur) + 2);
+            cur += first;
+            if (lines.length === 0) {
+                continue;
+            }
+            // if we start putting too many lines down, render in multiline format
+            if (lines.length > 4)
+                return renderMultiline();
+            // if spacer is not defined, separate all rows with a newline
+            if (!opts.spacer)
+                spacer = '\n';
+            cur += '\n';
+            cur += this.indent(lines.join('\n'), maxLength + 2);
+        }
+        if (cur) {
+            output += spacer;
+            output += cur;
+        }
+        return output.trim();
+    }
+    section(header, body) {
+        // Always render template strings with the provided render function before wrapping and indenting
+        let newBody;
+        if (typeof body === 'string') {
+            newBody = this.render(body);
+        }
+        else if (Array.isArray(body)) {
+            newBody = body.map((entry) => {
+                if ('name' in entry) {
+                    const tableEntry = entry;
+                    return [this.render(tableEntry.name), this.render(tableEntry.description)];
+                }
+                const [left, right] = entry;
+                return [this.render(left), right && this.render(right)];
+            });
+        }
+        else if ('header' in body) {
+            return this.section(body.header, body.body);
+        }
+        else {
+            newBody = body
+                .map((entry) => [entry.name, entry.description])
+                .map(([left, right]) => [this.render(left), right && this.render(right)]);
+        }
+        const output = [
+            (0, theme_1.colorize)(this.config?.theme?.sectionHeader, (0, theme_1.colorize)('bold', header)),
+            (0, theme_1.colorize)(this.config?.theme?.sectionDescription, this.indent(Array.isArray(newBody) ? this.renderList(newBody, { indentation: 2, stripAnsi: this.opts.stripAnsi }) : newBody)),
+        ].join('\n');
+        return this.opts.stripAnsi ? ansis_1.default.strip(output) : output;
+    }
+    /**
+     * Wrap text according to `opts.maxWidth` which is typically set to the terminal width. All text
+     * will be rendered before bring wrapped, otherwise it could mess up the lengths.
+     *
+     * A terminal will automatically wrap text, so this method is primarily used for indented
+     * text. For indented text, specify the indentation so it is taken into account during wrapping.
+     *
+     * Here is an example of wrapping with indentation.
+     * ```
+     * <------ terminal window width ------>
+     * <---------- no indentation --------->
+     * This is my text that will be wrapped
+     * once it passes maxWidth.
+     *
+     * <- indent -><------ text space ----->
+     *             This is my text that will
+     *             be wrapped once it passes
+     *             maxWidth.
+     *
+     * <-- indent not taken into account ->
+     *             This is my text that will
+     * be wrapped
+     *             once it passes maxWidth.
+     * ```
+     * @param body the text to wrap
+     * @param spacing the indentation size to subtract from the terminal width
+     * @returns the formatted wrapped text
+     */
+    wrap(body, spacing = this.indentSpacing) {
+        return (0, wrap_ansi_1.default)(this.render(body), this.opts.maxWidth - spacing, { hard: true });
+    }
+}
+exports.HelpFormatter = HelpFormatter;

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

@@ -0,0 +1,46 @@
+import { Command } from '../command';
+import * as Interfaces from '../interfaces';
+import { CommandHelp } from './command';
+import { HelpFormatter } from './formatter';
+export { CommandHelp } from './command';
+export { HelpFormatter, type HelpSection, type HelpSectionKeyValueTable, type HelpSectionRenderer } from './formatter';
+export { getHelpFlagAdditions, normalizeArgv, standardizeIDFromArgv } from './util';
+export declare abstract class HelpBase extends HelpFormatter {
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    /**
+     * Show help for an individual command
+     * @param command
+     * @param topics
+     */
+    abstract showCommandHelp(command: Command.Loadable, topics: Interfaces.Topic[]): Promise<void>;
+    /**
+     * Show help, used in multi-command CLIs
+     * @param args passed into your command, useful for determining which type of help to display
+     */
+    abstract showHelp(argv: string[]): Promise<void>;
+}
+export declare class Help extends HelpBase {
+    protected CommandHelpClass: typeof CommandHelp;
+    constructor(config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>);
+    private get _topics();
+    protected get sortedCommands(): Command.Loadable[];
+    protected get sortedTopics(): Interfaces.Topic[];
+    protected command(command: Command.Loadable): string;
+    protected description(c: Command.Loadable): string;
+    protected formatCommand(command: Command.Loadable): string;
+    protected formatCommands(commands: Array<Command.Loadable>): string;
+    formatRoot(): string;
+    protected formatTopic(topic: Interfaces.Topic): string;
+    protected formatTopics(topics: Interfaces.Topic[]): string;
+    protected getCommandHelpClass(command: Command.Loadable): CommandHelp;
+    protected log(...args: string[]): void;
+    showCommandHelp(command: Command.Loadable): Promise<void>;
+    showHelp(argv: string[]): Promise<void>;
+    protected showRootHelp(): Promise<void>;
+    protected showTopicHelp(topic: Interfaces.Topic): Promise<void>;
+    protected summary(c: Command.Loadable): string | undefined;
+}
+interface HelpBaseDerived {
+    new (config: Interfaces.Config, opts?: Partial<Interfaces.HelpOptions>): HelpBase;
+}
+export declare function loadHelpClass(config: Interfaces.Config): Promise<HelpBaseDerived>;

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

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Help = exports.HelpBase = exports.standardizeIDFromArgv = exports.normalizeArgv = exports.getHelpFlagAdditions = exports.HelpFormatter = exports.CommandHelp = void 0;
+exports.loadHelpClass = loadHelpClass;
+const ansis_1 = __importDefault(require("ansis"));
+const ts_path_1 = require("../config/ts-path");
+const error_1 = require("../errors/error");
+const module_loader_1 = require("../module-loader");
+const symbols_1 = require("../symbols");
+const cache_default_value_1 = require("../util/cache-default-value");
+const ids_1 = require("../util/ids");
+const util_1 = require("../util/util");
+const ux_1 = require("../ux");
+const theme_1 = require("../ux/theme");
+const command_1 = require("./command");
+const formatter_1 = require("./formatter");
+const root_1 = __importDefault(require("./root"));
+const util_2 = require("./util");
+var command_2 = require("./command");
+Object.defineProperty(exports, "CommandHelp", { enumerable: true, get: function () { return command_2.CommandHelp; } });
+var formatter_2 = require("./formatter");
+Object.defineProperty(exports, "HelpFormatter", { enumerable: true, get: function () { return formatter_2.HelpFormatter; } });
+var util_3 = require("./util");
+Object.defineProperty(exports, "getHelpFlagAdditions", { enumerable: true, get: function () { return util_3.getHelpFlagAdditions; } });
+Object.defineProperty(exports, "normalizeArgv", { enumerable: true, get: function () { return util_3.normalizeArgv; } });
+Object.defineProperty(exports, "standardizeIDFromArgv", { enumerable: true, get: function () { return util_3.standardizeIDFromArgv; } });
+function getHelpSubject(args, config) {
+    // for each help flag that starts with '--' create a new flag with same name sans '--'
+    const mergedHelpFlags = (0, util_2.getHelpFlagAdditions)(config);
+    for (const arg of args) {
+        if (arg === '--')
+            return;
+        if (mergedHelpFlags.includes(arg) || arg === 'help')
+            continue;
+        if (arg.startsWith('-'))
+            return;
+        return arg;
+    }
+}
+class HelpBase extends formatter_1.HelpFormatter {
+    constructor(config, opts = {}) {
+        super(config, opts);
+        if (!config.topicSeparator)
+            config.topicSeparator = ':'; // back-support @oclif/config
+    }
+}
+exports.HelpBase = HelpBase;
+class Help extends HelpBase {
+    CommandHelpClass = command_1.CommandHelp;
+    constructor(config, opts = {}) {
+        super(config, opts);
+    }
+    /*
+     * _topics is to work around Interfaces.topics mistakenly including commands that do
+     * not have children, as well as topics. A topic has children, either commands or other topics. When
+     * this is fixed upstream config.topics should return *only* topics with children,
+     * and this can be removed.
+     */
+    get _topics() {
+        return this.config.topics.filter((topic) => {
+            // it is assumed a topic has a child if it has children
+            const hasChild = this.config.topics.some((subTopic) => subTopic.name.includes(`${topic.name}:`));
+            return hasChild;
+        });
+    }
+    get sortedCommands() {
+        let { commands } = this.config;
+        commands = commands.filter((c) => this.opts.all || !c.hidden);
+        commands = (0, util_1.sortBy)(commands, (c) => c.id);
+        commands = (0, util_1.uniqBy)(commands, (c) => c.id);
+        return commands;
+    }
+    get sortedTopics() {
+        let topics = this._topics;
+        topics = topics.filter((t) => this.opts.all || !t.hidden);
+        topics = (0, util_1.sortBy)(topics, (t) => t.name);
+        topics = (0, util_1.uniqBy)(topics, (t) => t.name);
+        return topics;
+    }
+    command(command) {
+        return this.formatCommand(command);
+    }
+    description(c) {
+        const description = this.render(c.description || '');
+        if (c.summary) {
+            return description;
+        }
+        return description.split('\n').slice(1).join('\n');
+    }
+    formatCommand(command) {
+        if (this.config.topicSeparator !== ':') {
+            command.id = command.id.replaceAll(':', this.config.topicSeparator);
+            command.aliases = command.aliases && command.aliases.map((a) => a.replaceAll(':', this.config.topicSeparator));
+        }
+        const help = this.getCommandHelpClass(command);
+        return help.generate();
+    }
+    formatCommands(commands) {
+        if (commands.length === 0)
+            return '';
+        const body = this.renderList(commands
+            .filter((c) => (this.opts.hideAliasesFromRoot ? !c.aliases?.includes(c.id) : true))
+            .map((c) => {
+            if (this.config.topicSeparator !== ':')
+                c.id = c.id.replaceAll(':', this.config.topicSeparator);
+            const summary = this.summary(c);
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.command, c.id),
+                summary && (0, theme_1.colorize)(this.config?.theme?.sectionDescription, ansis_1.default.strip(summary)),
+            ];
+        }), {
+            indentation: 2,
+            spacer: '\n',
+            stripAnsi: this.opts.stripAnsi,
+        });
+        return this.section('COMMANDS', body);
+    }
+    formatRoot() {
+        const help = new root_1.default(this.config, this.opts);
+        return help.root();
+    }
+    formatTopic(topic) {
+        let description = this.render(topic.description || '');
+        const summary = description.split('\n')[0];
+        description = description.split('\n').slice(1).join('\n');
+        let topicID = `${topic.name}:COMMAND`;
+        if (this.config.topicSeparator !== ':')
+            topicID = topicID.replaceAll(':', this.config.topicSeparator);
+        let output = (0, util_1.compact)([
+            (0, theme_1.colorize)(this.config?.theme?.commandSummary, summary),
+            this.section(this.opts.usageHeader || 'USAGE', `${(0, theme_1.colorize)(this.config?.theme?.dollarSign, '$')} ${(0, theme_1.colorize)(this.config?.theme?.bin, this.config.bin)} ${topicID}`),
+            description &&
+                this.section('DESCRIPTION', this.wrap((0, theme_1.colorize)(this.config?.theme?.sectionDescription, description))),
+        ]).join('\n\n');
+        if (this.opts.stripAnsi)
+            output = ansis_1.default.strip(output);
+        return output + '\n';
+    }
+    formatTopics(topics) {
+        if (topics.length === 0)
+            return '';
+        const body = this.renderList(topics.map((c) => {
+            if (this.config.topicSeparator !== ':')
+                c.name = c.name.replaceAll(':', this.config.topicSeparator);
+            return [
+                (0, theme_1.colorize)(this.config?.theme?.topic, c.name),
+                c.description && this.render((0, theme_1.colorize)(this.config?.theme?.sectionDescription, c.description.split('\n')[0])),
+            ];
+        }), {
+            indentation: 2,
+            spacer: '\n',
+            stripAnsi: this.opts.stripAnsi,
+        });
+        return this.section('TOPICS', body);
+    }
+    getCommandHelpClass(command) {
+        return new this.CommandHelpClass(command, this.config, this.opts);
+    }
+    log(...args) {
+        return this.opts.sendToStderr ? ux_1.ux.stderr(args) : ux_1.ux.stdout(args);
+    }
+    async showCommandHelp(command) {
+        const name = command.id;
+        const depth = name.split(':').length;
+        const subTopics = this.sortedTopics.filter((t) => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
+        const subCommands = this.sortedCommands.filter((c) => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
+        const plugin = this.config.plugins.get(command.pluginName);
+        const state = this.config.pjson?.oclif?.state || plugin?.pjson?.oclif?.state || command.state;
+        if (state) {
+            this.log(state === 'deprecated'
+                ? `${(0, util_2.formatCommandDeprecationWarning)((0, ids_1.toConfiguredId)(name, this.config), command.deprecationOptions)}\n`
+                : `This command is in ${state}.\n`);
+        }
+        if (command.deprecateAliases && [...(command.aliases ?? []), ...(command.hiddenAliases ?? [])].includes(name)) {
+            const actualCmd = this.config.commands.find((c) => [...(c.aliases ?? []), ...(c.hiddenAliases ?? [])].includes(name));
+            const actualCmdName = actualCmd ? (0, ids_1.toConfiguredId)(actualCmd.id, this.config) : '';
+            const opts = { ...command.deprecationOptions, ...(actualCmd ? { to: actualCmdName } : {}) };
+            this.log(`${(0, util_2.formatCommandDeprecationWarning)((0, ids_1.toConfiguredId)(name, this.config), opts)}\n`);
+        }
+        const summary = this.summary(command);
+        if (summary) {
+            this.log(summary + '\n');
+        }
+        this.log(this.formatCommand(command));
+        this.log('');
+        if (subTopics.length > 0) {
+            this.log(this.formatTopics(subTopics));
+            this.log('');
+        }
+        if (subCommands.length > 0) {
+            const aliases = [];
+            const uniqueSubCommands = subCommands.filter((p) => {
+                aliases.push(...p.aliases);
+                return !aliases.includes(p.id);
+            });
+            this.log(this.formatCommands(uniqueSubCommands));
+            this.log('');
+        }
+    }
+    async showHelp(argv) {
+        const originalArgv = argv.slice(1);
+        argv = argv.filter((arg) => !(0, util_2.getHelpFlagAdditions)(this.config).includes(arg));
+        if (this.config.topicSeparator !== ':')
+            argv = (0, util_2.standardizeIDFromArgv)(argv, this.config);
+        const subject = getHelpSubject(argv, this.config);
+        if (!subject) {
+            if (this.config.isSingleCommandCLI) {
+                const rootCmd = this.config.findCommand(symbols_1.SINGLE_COMMAND_CLI_SYMBOL);
+                if (rootCmd) {
+                    // set the command id to an empty string to prevent the
+                    // SINGLE_COMMAND_CLI_SYMBOL from being displayed in the help output
+                    rootCmd.id = '';
+                    await this.showCommandHelp(rootCmd);
+                    return;
+                }
+            }
+            await this.showRootHelp();
+            return;
+        }
+        const command = this.config.findCommand(subject);
+        if (command) {
+            if (command.id === symbols_1.SINGLE_COMMAND_CLI_SYMBOL) {
+                // If the command is the root command of a single command CLI,
+                // then set the command id to an empty string to prevent the
+                // the SINGLE_COMMAND_CLI_SYMBOL from being displayed in the help output.
+                command.id = '';
+            }
+            if (command.hasDynamicHelp && command.pluginType !== 'jit') {
+                const loaded = await command.load();
+                for (const [name, flag] of Object.entries(loaded.flags ?? {})) {
+                    // As of v3 each flag that needs to be re-evaluated has the `hasDynamicHelp` property.
+                    // However, we cannot assume that the absence of this property means that the flag
+                    // doesn't need to be re-evaluated since any command from a v2 or older plugin will
+                    // not have the `hasDynamicHelp` property on it.
+                    // In the future we could improve performance by skipping any flag that doesn't
+                    // have `hasDynamicHelp === true`
+                    if (flag.type === 'boolean')
+                        continue;
+                    // eslint-disable-next-line no-await-in-loop
+                    command.flags[name].default = await (0, cache_default_value_1.cacheDefaultValue)(flag, false);
+                }
+                await this.showCommandHelp(command);
+            }
+            else {
+                await this.showCommandHelp(command);
+            }
+            return;
+        }
+        const topic = this.config.findTopic(subject);
+        if (topic) {
+            await this.showTopicHelp(topic);
+            return;
+        }
+        if (this.config.flexibleTaxonomy) {
+            const matches = this.config.findMatches(subject, originalArgv);
+            if (matches.length > 0) {
+                const result = await this.config.runHook('command_incomplete', {
+                    argv: originalArgv.filter((o) => !subject.split(':').includes(o)),
+                    id: subject,
+                    matches,
+                });
+                if (result.successes.length > 0)
+                    return;
+            }
+        }
+        (0, error_1.error)(`Command ${subject} not found.`);
+    }
+    async showRootHelp() {
+        let rootTopics = this.sortedTopics;
+        let rootCommands = this.sortedCommands;
+        const state = this.config.pjson?.oclif?.state;
+        if (state) {
+            this.log(state === 'deprecated' ? `${this.config.bin} is deprecated` : `${this.config.bin} is in ${state}.\n`);
+        }
+        this.log(this.formatRoot());
+        this.log('');
+        if (!this.opts.all) {
+            rootTopics = rootTopics.filter((t) => !t.name.includes(':'));
+            rootCommands = rootCommands.filter((c) => !c.id.includes(':'));
+        }
+        if (rootTopics.length > 0) {
+            this.log(this.formatTopics(rootTopics));
+            this.log('');
+        }
+        if (rootCommands.length > 0) {
+            rootCommands = rootCommands.filter((c) => c.id);
+            this.log(this.formatCommands(rootCommands));
+            this.log('');
+        }
+    }
+    async showTopicHelp(topic) {
+        const { name } = topic;
+        const depth = name.split(':').length;
+        const subTopics = this.sortedTopics.filter((t) => t.name.startsWith(name + ':') && t.name.split(':').length === depth + 1);
+        const commands = this.sortedCommands.filter((c) => c.id.startsWith(name + ':') && c.id.split(':').length === depth + 1);
+        const state = this.config.pjson?.oclif?.state;
+        if (state)
+            this.log(`This topic is in ${state}.\n`);
+        this.log(this.formatTopic(topic));
+        if (subTopics.length > 0) {
+            this.log(this.formatTopics(subTopics));
+            this.log('');
+        }
+        if (commands.length > 0) {
+            this.log(this.formatCommands(commands));
+            this.log('');
+        }
+    }
+    summary(c) {
+        if (this.opts.sections && !this.opts.sections.map((s) => s.toLowerCase()).includes('summary'))
+            return;
+        if (c.summary)
+            return (0, theme_1.colorize)(this.config?.theme?.commandSummary, this.render(c.summary.split('\n')[0]));
+        return c.description && (0, theme_1.colorize)(this.config?.theme?.commandSummary, this.render(c.description).split('\n')[0]);
+    }
+}
+exports.Help = Help;
+function extractClass(exported) {
+    return exported && exported.default ? exported.default : exported;
+}
+function determineLocation(helpClass) {
+    if (typeof helpClass === 'string')
+        return { identifier: 'default', target: helpClass };
+    if (!helpClass.identifier)
+        return { ...helpClass, identifier: 'default' };
+    return helpClass;
+}
+async function loadHelpClass(config) {
+    if (config.pjson.oclif?.helpClass) {
+        const { identifier, target } = determineLocation(config.pjson.oclif?.helpClass);
+        try {
+            const path = (await (0, ts_path_1.tsPath)(config.root, target)) ?? target;
+            const module = await (0, module_loader_1.load)(config, path);
+            const helpClass = module[identifier] ?? (identifier === 'default' ? extractClass(module) : undefined);
+            return extractClass(helpClass);
+        }
+        catch (error) {
+            throw new Error(`Unable to load configured help class "${target}", failed with message:\n${error.message}`);
+        }
+    }
+    return Help;
+}