@flowscripter/dynamic-cli-framework 1.7.2 → 1.7.4

package/dist/src/util/helpHelper.js

@@ -0,0 +1,497 @@
+import { distance } from "fastest-levenshtein";
+import { ArgumentValueTypeName, ComplexValueTypeName } from "../api/argument/ArgumentValueTypes.js";
+import { getGlobalCommandArgumentConfigurationKey, getSubCommandArgumentConfigurationKey, } from "./configHelper.js";
+const SYNTAX_INDENT_WIDTH = 2;
+const MINIMUM_SYNTAX_COLUMN_WIDTH = 15;
+const HELP_SYNTAX_INDENT = " ".repeat(SYNTAX_INDENT_WIDTH);
+function flattenHelpEntry(printerService, helpEntry, indentText, isRoot, isLastSibling, rows) {
+    let syntax = "";
+    if (helpEntry.syntax) {
+        if (isRoot) {
+            syntax = HELP_SYNTAX_INDENT + printerService.primary(helpEntry.syntax);
+        }
+        else {
+            let syntaxTreeChars = "";
+            if (indentText.length > 0) {
+                syntaxTreeChars = isLastSibling ? "└╴" : "├╴";
+            }
+            syntax =
+                HELP_SYNTAX_INDENT +
+                    printerService.secondary(indentText + syntaxTreeChars) +
+                    printerService.primary(helpEntry.syntax);
+        }
+    }
+    const description = helpEntry.description
+        ? printerService.secondary(helpEntry.description)
+        : undefined;
+    rows.push({ syntax, description });
+    if (helpEntry.helpSubEntries !== undefined) {
+        const nextIndent = indentText + (isLastSibling ? "  " : "│ ") + " ".repeat(helpEntry.subEntryIndent || 0);
+        for (let i = 0; i < helpEntry.helpSubEntries.length; i++) {
+            const sub = helpEntry.helpSubEntries[i];
+            flattenHelpEntry(printerService, sub, nextIndent, false, i === helpEntry.helpSubEntries.length - 1, rows);
+        }
+    }
+}
+export async function printHelpSections(printerService, tableGeneratorService, sections) {
+    const terminalWidth = printerService.stdoutColumns();
+    for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        if (section.title.length > 0) {
+            await printerService.print(`${printerService.emphasised(section.title)}\n\n`);
+        }
+        if (section.helpEntries.length === 0)
+            continue;
+        const rows = [];
+        for (const helpEntry of section.helpEntries) {
+            flattenHelpEntry(printerService, helpEntry, "", true, true, rows);
+        }
+        const hasDescriptions = rows.some((r) => r.description !== undefined);
+        if (hasDescriptions) {
+            const table = tableGeneratorService.createTable(rows.length, 2, {
+                border: false,
+                padding: 1,
+                maxWidth: terminalWidth,
+            });
+            table.column(0, { minWidth: MINIMUM_SYNTAX_COLUMN_WIDTH });
+            table.column(1, { flexWeight: 1 });
+            for (let r = 0; r < rows.length; r++) {
+                const row = rows[r];
+                table.cell(r, 0, row.syntax);
+                table.cell(r, 1, row.description ?? "");
+            }
+            const rendered = tableGeneratorService.render(table);
+            await printerService.print(rendered + "\n");
+        }
+        else {
+            for (const row of rows) {
+                await printerService.print(row.syntax + "\n");
+            }
+        }
+        await printerService.print("\n");
+    }
+}
+function getGlobalCommandArgumentForm(globalCommandArgument) {
+    let argumentSyntax = "";
+    switch (globalCommandArgument.type) {
+        case ArgumentValueTypeName.BOOLEAN:
+            argumentSyntax = "true|false";
+            break;
+        case ArgumentValueTypeName.INTEGER:
+            argumentSyntax = "<integer_value>";
+            break;
+        case ArgumentValueTypeName.NUMBER:
+            argumentSyntax = "<number_value>";
+            break;
+        case ArgumentValueTypeName.STRING:
+            argumentSyntax = "<string_value>";
+            break;
+    }
+    if (globalCommandArgument.isOptional ||
+        globalCommandArgument.type === ArgumentValueTypeName.BOOLEAN) {
+        argumentSyntax = `[${argumentSyntax}]`;
+    }
+    return argumentSyntax;
+}
+export function getGlobalArgumentHelpEntry(cliConfig, includeEnvVars, globalCommand) {
+    const { argument } = globalCommand;
+    let description = globalCommand.description || "";
+    if (argument === undefined) {
+        return { syntax: "", description };
+    }
+    const syntax = getGlobalCommandArgumentForm(argument);
+    const notesItems = [];
+    if (argument.allowableValues !== undefined && argument.allowableValues.length > 0) {
+        notesItems.push(`valid values: ${argument.allowableValues.join("|")}`);
+    }
+    else {
+        switch (argument.type) {
+            case ArgumentValueTypeName.STRING:
+                notesItems.push("string value");
+                break;
+            case ArgumentValueTypeName.INTEGER:
+                notesItems.push("integer value");
+                break;
+            case ArgumentValueTypeName.NUMBER:
+                notesItems.push("number value");
+                break;
+        }
+        if (argument.minValueInclusive !== undefined || argument.maxValueInclusive !== undefined) {
+            let range = "..";
+            if (argument.minValueInclusive !== undefined) {
+                range = argument.minValueInclusive + range;
+            }
+            if (argument.maxValueInclusive !== undefined) {
+                range += argument.maxValueInclusive;
+            }
+            notesItems.push(range);
+        }
+    }
+    if (argument.defaultValue !== undefined) {
+        notesItems.push(`default: ${argument.defaultValue}`);
+    }
+    if (includeEnvVars) {
+        const configurationKey = getGlobalCommandArgumentConfigurationKey(cliConfig, globalCommand, argument);
+        if (configurationKey !== undefined) {
+            notesItems.push(`env var: ${configurationKey}`);
+        }
+    }
+    if (notesItems.length > 0) {
+        if (description.length === 0) {
+            description = `(${notesItems.join(", ")})`;
+        }
+        else {
+            description = `${description} (${notesItems.join(", ")})`;
+        }
+    }
+    return { syntax, description };
+}
+export function getSubCommandArgumentsSyntax(subCommand) {
+    let syntax = "";
+    subCommand.options.forEach((option) => {
+        let optionSyntax = `--${option.name}`;
+        switch (option.type) {
+            case ArgumentValueTypeName.BOOLEAN:
+                optionSyntax = `${optionSyntax} [true|false]`;
+                break;
+            case ArgumentValueTypeName.INTEGER:
+                optionSyntax = `${optionSyntax} <integer_value>`;
+                break;
+            case ArgumentValueTypeName.NUMBER:
+                optionSyntax = `${optionSyntax} <number_value>`;
+                break;
+            case ArgumentValueTypeName.STRING:
+                optionSyntax = `${optionSyntax} <string_value>`;
+                break;
+            case ComplexValueTypeName.COMPLEX:
+                optionSyntax = `${optionSyntax} <complex_value>`;
+                break;
+        }
+        if (option.isOptional || option.defaultValue !== undefined) {
+            optionSyntax = ` [${optionSyntax}]`;
+        }
+        else {
+            optionSyntax = ` ${optionSyntax}`;
+        }
+        if (option.isArray) {
+            optionSyntax = `${optionSyntax}...`;
+        }
+        syntax = `${syntax}${optionSyntax}`;
+    });
+    subCommand.positionals.forEach((positional) => {
+        let positionalSyntax = `<${positional.name}>`;
+        if (positional.isVarargOptional) {
+            positionalSyntax = ` [${positionalSyntax}]`;
+        }
+        else {
+            positionalSyntax = ` ${positionalSyntax}`;
+        }
+        if (positional.isVarargMultiple) {
+            positionalSyntax = `${positionalSyntax}...`;
+        }
+        syntax = `${syntax}${positionalSyntax}`;
+    });
+    return syntax;
+}
+function getOptionHelpEntry(cliConfig, includeEnvVars, command, option, subEntryIndent = 0, optionAncestry = []) {
+    let subEntries;
+    let optionCharacters = "--";
+    let aliasCharacter = "-";
+    let newSubEntryIndent = option.name.length;
+    if (subEntryIndent > 0) {
+        optionCharacters = ".";
+        aliasCharacter = ".";
+        newSubEntryIndent += 1;
+    }
+    const notesItems = [];
+    if (option.type === ComplexValueTypeName.COMPLEX) {
+        subEntries = [];
+        option.properties.forEach((property) => {
+            subEntries.push(getOptionHelpEntry(cliConfig, includeEnvVars, command, property, newSubEntryIndent, [
+                ...optionAncestry,
+                option,
+            ]));
+        });
+    }
+    else {
+        if (option.allowableValues !== undefined && option.allowableValues.length > 0) {
+            notesItems.push(`valid values: ${option.allowableValues.join("|")}`);
+        }
+        else {
+            switch (option.type) {
+                case ArgumentValueTypeName.STRING:
+                    notesItems.push(`string value`);
+                    break;
+                case ArgumentValueTypeName.INTEGER:
+                    notesItems.push(`integer value`);
+                    break;
+                case ArgumentValueTypeName.NUMBER:
+                    notesItems.push(`number value`);
+                    break;
+                case ArgumentValueTypeName.BOOLEAN:
+                    notesItems.push(`boolean value`);
+                    break;
+            }
+        }
+    }
+    if (option.minValueInclusive !== undefined || option.maxValueInclusive !== undefined) {
+        let range = "..";
+        if (option.minValueInclusive !== undefined) {
+            range = option.minValueInclusive + range;
+        }
+        if (option.maxValueInclusive !== undefined) {
+            range += option.maxValueInclusive;
+        }
+        notesItems.push(range);
+    }
+    if (option.defaultValue !== undefined) {
+        notesItems.push(`default: ${Array.isArray(option.defaultValue)
+            ? `${option.defaultValue.join(", ")}`
+            : `${option.defaultValue}`}`);
+    }
+    if (option.isOptional) {
+        notesItems.push("optional");
+    }
+    if (option.isArray) {
+        notesItems.push("array");
+    }
+    if (includeEnvVars && option.type !== ComplexValueTypeName.COMPLEX) {
+        const configurationKey = getSubCommandArgumentConfigurationKey(cliConfig, command, [
+            ...optionAncestry,
+            option,
+        ]);
+        if (configurationKey !== undefined) {
+            notesItems.push(`env var: ${configurationKey}`);
+        }
+    }
+    let description = option.description || "";
+    if (description.length > 0) {
+        if (notesItems.length > 0) {
+            description = `${description} (${notesItems.join(", ")})`;
+        }
+    }
+    else if (notesItems.length > 0) {
+        description = "(" + notesItems.join(", ") + ")";
+    }
+    return {
+        syntax: `${optionCharacters}${option.name}${option.shortAlias !== undefined ? `, ${aliasCharacter}${option.shortAlias}` : ""}`,
+        description,
+        subEntryIndent: newSubEntryIndent,
+        helpSubEntries: subEntries,
+    };
+}
+function getPositionalHelpEntry(cliConfig, includeEnvVars, command, positional) {
+    const notesItems = [];
+    if (positional.allowableValues !== undefined && positional.allowableValues.length > 0) {
+        notesItems.push(`valid values: ${positional.allowableValues.join("|")}`);
+    }
+    else {
+        switch (positional.type) {
+            case ArgumentValueTypeName.STRING:
+                notesItems.push(`string value`);
+                break;
+            case ArgumentValueTypeName.INTEGER:
+                notesItems.push(`integer value`);
+                break;
+            case ArgumentValueTypeName.NUMBER:
+                notesItems.push(`number value`);
+                break;
+            case ArgumentValueTypeName.BOOLEAN:
+                notesItems.push(`boolean value`);
+                break;
+        }
+    }
+    if (positional.minValueInclusive !== undefined || positional.maxValueInclusive !== undefined) {
+        let range = "..";
+        if (positional.minValueInclusive !== undefined) {
+            range = positional.minValueInclusive + range;
+        }
+        if (positional.maxValueInclusive !== undefined) {
+            range += positional.maxValueInclusive;
+        }
+        notesItems.push(range);
+    }
+    if (positional.isVarargOptional) {
+        notesItems.push("optional");
+    }
+    if (positional.isVarargMultiple) {
+        notesItems.push("array");
+    }
+    if (includeEnvVars) {
+        const configurationKey = getSubCommandArgumentConfigurationKey(cliConfig, command, [
+            positional,
+        ]);
+        if (configurationKey !== undefined) {
+            notesItems.push(`env var: ${configurationKey}`);
+        }
+    }
+    let description = positional.description || "";
+    if (description.length > 0) {
+        if (notesItems.length > 0) {
+            description = `${description} (${notesItems.join(", ")})`;
+        }
+    }
+    else if (notesItems.length > 0) {
+        description = "(" + notesItems.join(", ") + ")";
+    }
+    return {
+        syntax: `<${positional.name}>`,
+        description,
+    };
+}
+export function getCommandArgsHelpSections(cliConfig, includeEnvVars, subCommand, isSingleCommandApp) {
+    const helpSections = [];
+    if (subCommand.options.length > 0 || subCommand.positionals.length > 0) {
+        const argumentsSection = {
+            title: `${isSingleCommandApp ? "Command " : ""}Arguments`,
+            helpEntries: [],
+        };
+        subCommand.options.forEach((option) => {
+            argumentsSection.helpEntries.push(getOptionHelpEntry(cliConfig, includeEnvVars, subCommand, option));
+        });
+        subCommand.positionals.forEach((positional) => {
+            argumentsSection.helpEntries.push(getPositionalHelpEntry(cliConfig, includeEnvVars, subCommand, positional));
+        });
+        helpSections.push(argumentsSection);
+    }
+    return helpSections;
+}
+export function getCommandExamplesHelpSections(printerService, context, subCommand) {
+    const helpSections = [];
+    if (subCommand.usageExamples !== undefined && subCommand.usageExamples.length > 0) {
+        const usageSection = {
+            title: subCommand.usageExamples.length > 1 ? "Examples" : "Example",
+            helpEntries: [],
+        };
+        helpSections.push(usageSection);
+        subCommand.usageExamples.forEach((usageExample, index) => {
+            if (usageExample.description != null && usageExample.description.length > 0) {
+                usageSection.helpEntries.push({
+                    syntax: `${printerService.italic(usageExample.description)}:\n`,
+                });
+            }
+            usageSection.helpEntries.push({
+                syntax: `$ ${context.cliConfig.name} ${subCommand.name} ${usageExample.exampleArguments}`,
+            });
+            if (usageExample.output !== undefined) {
+                usageExample.output.forEach((output) => {
+                    usageSection.helpEntries.push({
+                        syntax: printerService.secondary(output),
+                    });
+                });
+            }
+            if (index < subCommand.usageExamples.length - 1) {
+                usageSection.helpEntries.push({
+                    syntax: "",
+                });
+            }
+        });
+    }
+    return helpSections;
+}
+export function getMultiCommandAppSyntax(context, globalModifierCommands, globalCommands, groupCommands, subCommands) {
+    const globalPrefix = groupCommands.length > 0 || subCommands.length > 0 ? "global_" : "";
+    let syntax = context.cliConfig.name || "";
+    if (globalModifierCommands.length > 0) {
+        syntax += ` [<${globalPrefix}option>`;
+        // dont render global_option arg if none defined
+        const noArg = globalModifierCommands.every((modifier) => modifier.argument === undefined);
+        if (!noArg) {
+            // render global_option arg in [] if all modifiers have non-optional, non-boolean arg with no default
+            const optionArgMandatory = globalModifierCommands.every((modifier) => modifier.argument !== undefined &&
+                !modifier.argument.isOptional &&
+                modifier.argument.defaultValue === undefined &&
+                modifier.argument.type !== ArgumentValueTypeName.BOOLEAN);
+            syntax += optionArgMandatory ? " <value>" : " [<value>]";
+        }
+        syntax += "]";
+    }
+    if (globalModifierCommands.length > 1) {
+        syntax += "...";
+    }
+    let arg = false;
+    let argOptional = false;
+    let argValueOptional = false;
+    let multipleArg = false;
+    const commandClauses = [];
+    if (globalCommands.length > 0) {
+        commandClauses.push(`<${globalPrefix}command>`);
+        arg = globalCommands.some((globalCommand) => globalCommand.argument !== undefined);
+        if (arg) {
+            argOptional = globalCommands.some((globalCommand) => globalCommand.argument !== undefined &&
+                ((globalCommand.argument.isOptional !== undefined && globalCommand.argument.isOptional) ||
+                    globalCommand.argument.defaultValue !== undefined));
+            argValueOptional = globalCommands.some((globalCommand) => globalCommand.argument !== undefined &&
+                globalCommand.argument.type === ArgumentValueTypeName.BOOLEAN);
+        }
+    }
+    if (groupCommands.length > 0 || subCommands.length > 0) {
+        commandClauses.push("<command>");
+        arg =
+            arg ||
+                groupCommands.some((groupCommand) => groupCommand.memberSubCommands.some((memberCommand) => memberCommand.options.length > 0 || memberCommand.positionals.length > 0)) ||
+                subCommands.some((subCommand) => subCommand.options.length > 0 || subCommand.positionals.length > 0);
+        if (arg) {
+            argOptional =
+                argOptional ||
+                    groupCommands.some((groupCommand) => groupCommand.memberSubCommands.some((memberCommand) => memberCommand.options.some((option) => (option.isOptional !== undefined && option.isOptional) ||
+                        option.defaultValue !== undefined) ||
+                        memberCommand.positionals.some((positional) => positional.isVarargOptional !== undefined && positional.isVarargOptional))) ||
+                    subCommands.some((subCommand) => subCommand.options.some((option) => (option.isOptional !== undefined && option.isOptional) ||
+                        option.defaultValue !== undefined) ||
+                        subCommand.positionals.some((positional) => positional.isVarargOptional !== undefined && positional.isVarargOptional));
+            argValueOptional =
+                argValueOptional ||
+                    groupCommands.some((groupCommand) => groupCommand.memberSubCommands.some((memberCommand) => memberCommand.options.some((option) => option.type === ArgumentValueTypeName.BOOLEAN ||
+                        memberCommand.positionals.some((positional) => positional.type === ArgumentValueTypeName.BOOLEAN)))) ||
+                    subCommands.some((subCommand) => subCommand.options.some((option) => option.type === ArgumentValueTypeName.BOOLEAN) ||
+                        subCommand.positionals.some((positional) => positional.type === ArgumentValueTypeName.BOOLEAN));
+            multipleArg =
+                multipleArg ||
+                    groupCommands.some((groupCommand) => groupCommand.memberSubCommands.some((memberCommand) => memberCommand.options.some((option) => option.isArray) ||
+                        memberCommand.positionals.some((positional) => positional.isVarargMultiple))) ||
+                    subCommands.some((subCommand) => subCommand.options.some((option) => option.isArray) ||
+                        subCommand.positionals.some((positional) => positional.isVarargMultiple));
+        }
+    }
+    if (commandClauses.length > 0) {
+        let subSyntax = `${commandClauses.join("|")}`;
+        // dont render arg if none defined (no global arg or no option/positional)
+        if (arg) {
+            let argSyntax = "<arg>";
+            // render arg value in [] if some are optional
+            argSyntax += argValueOptional ? " [<value>]" : " <value>";
+            // dont render arg in [] if none are optional and have no default
+            subSyntax += argOptional
+                ? ` [${argSyntax}]`
+                : multipleArg
+                    ? ` <${argSyntax}>`
+                    : ` ${argSyntax}`;
+            // check to render multiple arg
+            if (multipleArg) {
+                subSyntax += "...";
+            }
+        }
+        syntax += ` ${subSyntax}`;
+    }
+    return syntax;
+}
+export function findPossibleCommandNames(commandName, groupCommands, subCommands) {
+    const levenCommandArray = new Array();
+    subCommands.forEach((subCommand) => {
+        levenCommandArray.push([distance(subCommand.name, commandName), subCommand.name]);
+    });
+    groupCommands.forEach((groupCommand) => {
+        groupCommand.memberSubCommands
+            .filter((memberCommand) => !memberCommand.disableGenericHelpDisplay)
+            .forEach((memberCommand) => {
+            const memberName = `${groupCommand.name}:${memberCommand.name}`;
+            levenCommandArray.push([distance(memberName, commandName), memberName]);
+        });
+    });
+    return levenCommandArray
+        .sort((a, b) => a[0] - b[0])
+        .slice(0, 2)
+        .filter((value) => value[0] < 3)
+        .map((value) => value[1]);
+}

package/dist/src/util/logger.js

@@ -0,0 +1,81 @@
+import process from "node:process";
+const LEVEL_PADDINGS = {
+    TRACE: "    ",
+    DEBUG: "    ",
+    INFO: "     ",
+    WARN: "     ",
+    ERROR: "    ",
+};
+const debugEnabled = process.env["DYNAMIC_CLI_FRAMEWORK_DEBUG"] !== undefined;
+let maxLoggerNameLength = 0;
+const LOGGER_NAME_PADDINGS = {};
+function getDefaultLogger() {
+    return {
+        trace: () => { },
+        debug: (message, ...optionalParams) => {
+            console.debug(message, ...optionalParams);
+        },
+        info: (message, ...optionalParams) => {
+            console.info(message, ...optionalParams);
+        },
+        warn: (message, ...optionalParams) => {
+            console.warn(message, ...optionalParams);
+        },
+        error: (message, ...optionalParams) => {
+            console.error(message, ...optionalParams);
+        },
+    };
+}
+function wrapDefaultLogger(loggerName, levelPadding, loggerFunction) {
+    return (message, ...optionalParams) => {
+        if (message instanceof Function) {
+            loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${message()}`, ...optionalParams);
+            return;
+        }
+        if (message instanceof Object) {
+            loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${JSON.stringify(message)}`, ...optionalParams);
+            return;
+        }
+        loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${message}`, ...optionalParams);
+    };
+}
+/**
+ * Retrieves a logger instance with the specified name. If the name length exceeds the current maximum logger name length,
+ * it updates the padding for all existing logger names to ensure consistent formatting.
+ *
+ * @param loggerName The name of the logger to retrieve.
+ * @returns A logger instance with the specified name.
+ */
+export default function getLogger(loggerName) {
+    const g = globalThis;
+    if (g.defaultLogger === undefined) {
+        g.defaultLogger = getDefaultLogger();
+    }
+    const defaultLogger = g.defaultLogger;
+    if (loggerName.length > maxLoggerNameLength) {
+        maxLoggerNameLength = loggerName.length;
+        for (const key of Object.keys(LOGGER_NAME_PADDINGS)) {
+            LOGGER_NAME_PADDINGS[key] = " ".repeat(maxLoggerNameLength - key.length);
+        }
+        LOGGER_NAME_PADDINGS[loggerName] = "";
+    }
+    else if (LOGGER_NAME_PADDINGS[loggerName] === undefined) {
+        LOGGER_NAME_PADDINGS[loggerName] = " ".repeat(maxLoggerNameLength - loggerName.length);
+    }
+    if (debugEnabled) {
+        return {
+            trace: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.TRACE, defaultLogger.trace),
+            debug: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.DEBUG, defaultLogger.debug),
+            info: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.INFO, defaultLogger.info),
+            warn: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.WARN, defaultLogger.warn),
+            error: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.ERROR, defaultLogger.error),
+        };
+    }
+    return {
+        trace: () => { },
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.ERROR, defaultLogger.error),
+    };
+}

package/dist/src/util/runnerHelper.d.ts

@@ -3,6 +3,7 @@ import type Context from "../api/Context.ts";
 import type CommandRegistry from "../runtime/registry/CommandRegistry.ts";
 export declare function printParseResultError(context: Context, parseResult: ParseResult, isDefaultCommand?: boolean): Promise<void>;
 export declare function printCommandExecutionError(context: Context, parseResult: ParseResult, err: Error, isDefaultCommand?: boolean): Promise<void>;
+export declare function printRuntimeError(context: Context, err: Error): Promise<void>;
 export declare function printNoCommandSpecifiedError(context: Context): Promise<void>;
 export declare function printNoCommandRecognisedError(context: Context, commandRegistry: CommandRegistry, availableArgs: ReadonlyArray<string>): Promise<void>;
 export declare function printUnusedArgsWarning(context: Context, overallUnusedArgs: ReadonlyArray<string>): Promise<void>;

package/dist/src/util/runnerHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runnerHelper.d.ts","sourceRoot":"","sources":["../../../src/util/runnerHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,eAAe,MAAM,wCAAwC,CAAC;AAY1E,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,gBAAgB,UAAQ,iBAiBzB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,KAAK,EACV,gBAAgB,UAAQ,iBAiBzB;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,OAAO,iBAGlE;AAED,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,iBA4BrC;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,iBAQzC"}
+{"version":3,"file":"runnerHelper.d.ts","sourceRoot":"","sources":["../../../src/util/runnerHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAE7C,OAAO,KAAK,eAAe,MAAM,wCAAwC,CAAC;AAY1E,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,gBAAgB,UAAQ,iBAiBzB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,KAAK,EACV,gBAAgB,UAAQ,iBAiBzB;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,iBAMnE;AAED,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,OAAO,iBAGlE;AAED,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,iBAgCrC;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,iBAQzC"}

package/dist/src/util/runnerHelper.js

@@ -0,0 +1,80 @@
+import { Icon, PRINTER_SERVICE_ID } from "../api/service/core/PrinterService.js";
+import { isGlobalCommand, isGlobalModifierCommand } from "../runtime/command/CommandTypeGuards.js";
+import { getInvalidArgumentString } from "../runtime/values/argumentValueValidation.js";
+import { findPossibleCommandNames } from "./helpHelper.js";
+function getCommandString(printerService, parseResult) {
+    const { command, groupCommand } = parseResult;
+    if (groupCommand) {
+        return printerService.yellow(`'${groupCommand.name}:${command.name}'`);
+    }
+    return printerService.yellow(`'${command.name}'`);
+}
+export async function printParseResultError(context, parseResult, isDefaultCommand = false) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    const commandErrorString = isDefaultCommand
+        ? "Parse error: "
+        : `Parse error for command: ${getCommandString(printerService, parseResult)}`;
+    const { command, invalidArguments } = parseResult;
+    let errorString = "=> ";
+    const skipArgName = isGlobalModifierCommand(command) || isGlobalCommand(command);
+    const argsString = invalidArguments
+        .map((arg) => getInvalidArgumentString(arg, skipArgName))
+        .join(", ");
+    errorString = `${errorString}${printerService.yellow(argsString)}`;
+    await printerService.error(`${commandErrorString}\n  ${errorString}\n\n`, Icon.FAILURE);
+}
+export async function printCommandExecutionError(context, parseResult, err, isDefaultCommand = false) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    const commandErrorString = isDefaultCommand
+        ? "Execution error: "
+        : `Execution error for command: ${getCommandString(printerService, parseResult)}`;
+    if (err !== undefined) {
+        await printerService.error(`${commandErrorString}\n  => ${printerService.yellow(err.message)}\n\n`, Icon.FAILURE);
+    }
+    else {
+        await printerService.error(`${commandErrorString}\n  => ${printerService.yellow("error is undefined")}\n\n`, Icon.FAILURE);
+    }
+}
+export async function printRuntimeError(context, err) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    await printerService.error(`Execution error: \n  => ${printerService.yellow(err.message)}\n\n`, Icon.FAILURE);
+}
+export async function printNoCommandSpecifiedError(context) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    await printerService.error("No command specified\n\n");
+}
+export async function printNoCommandRecognisedError(context, commandRegistry, availableArgs) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    await printerService.error("No command recognised\n\n");
+    if (availableArgs.length > 0) {
+        const groupCommands = commandRegistry
+            .getGroupCommands()
+            .filter((command) => !command.disableGenericHelpDisplay);
+        const subCommands = commandRegistry
+            .getSubCommands()
+            .filter((command) => !command.disableGenericHelpDisplay);
+        const allPossibleCommandNames = [];
+        for (const arg of availableArgs) {
+            // look for other possible matches
+            const possibleCommandNames = findPossibleCommandNames(arg, groupCommands, subCommands);
+            // add the possible command names to the list if not already present
+            for (const possibleCommandName of possibleCommandNames) {
+                if (!allPossibleCommandNames.includes(possibleCommandName)) {
+                    allPossibleCommandNames.push(possibleCommandName);
+                }
+            }
+        }
+        if (allPossibleCommandNames.length > 0) {
+            await printerService.print(`Possible matches: ${allPossibleCommandNames.join(", ")}\n\n`, Icon.INFORMATION);
+        }
+    }
+}
+export async function printUnusedArgsWarning(context, overallUnusedArgs) {
+    const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+    if (overallUnusedArgs.length === 1) {
+        await printerService.warn(`Unused arg: ${overallUnusedArgs[0]}\n\n`, Icon.ALERT);
+    }
+    else {
+        await printerService.warn(`Unused args: ${overallUnusedArgs.join(" ")}\n\n`, Icon.ALERT);
+    }
+}