@flowscripter/dynamic-cli-framework 1.1.5 → 1.2.0

package/src/util/envVarHelper.ts

@@ -21,7 +21,7 @@ import type ComplexOption from "../api/argument/ComplexOption.ts";
 
 function getKeySegment(segment: string) {
   let keySegment = segment.replace("-", "_").toUpperCase();
-  if (keySegment[0].match(/[0-9]/)) {
+  if (keySegment[0]!.match(/[0-9]/)) {
     keySegment = `_${keySegment}`;
   }
   return keySegment;
@@ -152,7 +152,7 @@ function getOptionValuesFromEnvVars(
               getOptionValuesFromEnvVars(
                 (envVarValues[option.name] as Array<PopulatedArgumentValues>)[
                   index
-                ],
+                ]!,
                 matches,
                 env,
                 property,

package/src/util/helpHelper.ts

@@ -1,3 +1,4 @@
+import { distance } from "fastest-levenshtein";
 import type GlobalCommand from "../api/command/GlobalCommand.ts";
 import type GlobalCommandArgument from "../api/argument/GlobalCommandArgument.ts";
 import {
@@ -20,12 +21,12 @@ import type CLIConfig from "../api/CLIConfig.ts";
 import type PrinterService from "../api/service/core/PrinterService.ts";
 import type SubCommandArgument from "../api/argument/SubCommandArgument.ts";
 import type ComplexOption from "../api/argument/ComplexOption.ts";
+import type TableGeneratorService from "../api/service/core/TableGeneratorService.ts";
+import Table from "../api/service/core/Table.ts";
 
 const SYNTAX_INDENT_WIDTH = 2;
-const SYNTAX_MIN_PADDING_WIDTH = 2;
 const MINIMUM_SYNTAX_COLUMN_WIDTH = 15;
 const HELP_SYNTAX_INDENT = " ".repeat(SYNTAX_INDENT_WIDTH);
-const HELP_SYNTAX_PADDING = " ".repeat(SYNTAX_MIN_PADDING_WIDTH);
 
 export interface HelpEntry {
   readonly syntax: string;
@@ -39,169 +40,113 @@ export interface HelpSection {
   readonly helpEntries: Array<HelpEntry>;
 }
 
-async function printSingleHelpEntry(
+interface FlattenedRow {
+  syntax: string;
+  description?: string;
+}
+
+function flattenHelpEntry(
   printerService: PrinterService,
   helpEntry: HelpEntry,
-  syntaxWidth: number,
   indentText: string,
   isRoot: boolean,
   isLastSibling: boolean,
-): Promise<void> {
-  let text = "";
-  const notesIndent = syntaxWidth;
-  let syntaxTreeChars = "";
-  let totalSyntaxLength = 0;
-
+  rows: FlattenedRow[],
+): void {
+  let syntax = "";
   if (helpEntry.syntax) {
     if (isRoot) {
-      text += HELP_SYNTAX_INDENT + printerService.primary(helpEntry.syntax);
-      totalSyntaxLength = SYNTAX_INDENT_WIDTH + helpEntry.syntax.length;
+      syntax = HELP_SYNTAX_INDENT + printerService.primary(helpEntry.syntax);
     } else {
+      let syntaxTreeChars = "";
       if (indentText.length > 0) {
         syntaxTreeChars = isLastSibling ? "└╴" : "├╴";
       }
-      text += HELP_SYNTAX_INDENT +
+      syntax = HELP_SYNTAX_INDENT +
         printerService.secondary(indentText + syntaxTreeChars) +
         printerService.primary(helpEntry.syntax);
-      totalSyntaxLength = SYNTAX_INDENT_WIDTH + indentText.length +
-        syntaxTreeChars.length + helpEntry.syntax.length;
-    }
-  }
-  if (helpEntry.description) {
-    if (helpEntry.syntax) {
-      if (totalSyntaxLength > notesIndent) {
-        text += HELP_SYNTAX_PADDING +
-          printerService.secondary(helpEntry.description);
-      } else {
-        text += " ".repeat(syntaxWidth - totalSyntaxLength) +
-          printerService.secondary(helpEntry.description);
-      }
-    } else {
-      text += HELP_SYNTAX_PADDING +
-        printerService.secondary(helpEntry.description);
     }
   }
-  text += "\n";
-  await printerService.print(text);
-}
 
-async function printHelpEntry(
-  printerService: PrinterService,
-  helpEntry: HelpEntry,
-  syntaxWidth: number,
-  indentText: string,
-  isRoot: boolean,
-  hasChildren: boolean,
-  isLastSibling: boolean,
-): Promise<void> {
-  if (hasChildren) {
-    await printSingleHelpEntry(
-      printerService,
-      helpEntry,
-      syntaxWidth,
-      indentText,
-      isRoot,
-      isLastSibling,
-    );
-    indentText += (isLastSibling ? "  " : "│ ") +
+  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 helpSubEntry = helpEntry.helpSubEntries![i];
-      const helpSubEntryHasChildren = helpSubEntry.helpSubEntries !== undefined;
-      const helpSubEntryIsLastSibling =
-        i === helpEntry.helpSubEntries!.length - 1;
-      await printHelpEntry(
+    for (let i = 0; i < helpEntry.helpSubEntries.length; i++) {
+      const sub = helpEntry.helpSubEntries[i]!;
+      flattenHelpEntry(
         printerService,
-        helpSubEntry,
-        syntaxWidth,
-        indentText,
+        sub,
+        nextIndent,
         false,
-        helpSubEntryHasChildren,
-        helpSubEntryIsLastSibling,
+        i === helpEntry.helpSubEntries.length - 1,
+        rows,
       );
     }
-  } else {
-    await printSingleHelpEntry(
-      printerService,
-      helpEntry,
-      syntaxWidth,
-      indentText,
-      isRoot,
-      isLastSibling,
-    );
-  }
-}
-
-function getSyntaxWidth(helpEntry: HelpEntry, indent: number): number {
-  if (
-    (helpEntry.helpSubEntries === undefined) ||
-    (helpEntry.helpSubEntries.length === 0)
-  ) {
-    // 2 is for the tree characters
-    let finalWidth = SYNTAX_INDENT_WIDTH + indent + 2 +
-      SYNTAX_MIN_PADDING_WIDTH;
-    if (helpEntry.syntax) {
-      finalWidth += helpEntry.syntax.length;
-    }
-    return finalWidth;
   }
-  let maxSubIndent = 0;
-  helpEntry.helpSubEntries.forEach((helpSubEntry) => {
-    // 2 is for the tree characters
-    const subEntryWidth = getSyntaxWidth(
-      helpSubEntry,
-      (helpEntry.subEntryIndent ? helpEntry.subEntryIndent : 0) + 2,
-    );
-    if (subEntryWidth > maxSubIndent) {
-      maxSubIndent = subEntryWidth;
-    }
-  });
-  return indent + maxSubIndent;
 }
 
 export async function printHelpSections(
   printerService: PrinterService,
+  tableGeneratorService: TableGeneratorService,
   sections: Array<HelpSection>,
 ): Promise<void> {
-  // calculate alignment
-  let syntaxWidth = SYNTAX_INDENT_WIDTH + MINIMUM_SYNTAX_COLUMN_WIDTH +
-    SYNTAX_MIN_PADDING_WIDTH;
-  sections.forEach((section) => {
-    section.helpEntries.forEach((helpEntry) => {
-      const entrySyntaxWidth = getSyntaxWidth(helpEntry, 0);
-      // don't expand out if no description as we can overwrite that space on the line
-      if (
-        helpEntry.description && (helpEntry.description.length > 0) &&
-        (entrySyntaxWidth > syntaxWidth)
-      ) {
-        syntaxWidth = entrySyntaxWidth;
-      }
-    });
-  });
+  const terminalWidth = printerService.stdoutColumns();
 
-  // print the help
   for (let i = 0; i < sections.length; i++) {
-    const section = sections[i];
+    const section = sections[i]!;
     if (section.title.length > 0) {
       await printerService.print(
         `${printerService.emphasised(section.title)}\n\n`,
       );
     }
-    for (let j = 0; j < section.helpEntries.length; j++) {
-      const helpEntry = section.helpEntries[j];
-      await printHelpEntry(
+
+    if (section.helpEntries.length === 0) continue;
+
+    const rows: FlattenedRow[] = [];
+    for (const helpEntry of section.helpEntries) {
+      flattenHelpEntry(
         printerService,
         helpEntry,
-        syntaxWidth,
         "",
         true,
-        helpEntry.helpSubEntries !== undefined,
         true,
+        rows,
       );
     }
-    if (section.helpEntries.length > 0) {
-      await printerService.print("\n");
+
+    const hasDescriptions = rows.some((r) => r.description !== undefined);
+
+    if (hasDescriptions) {
+      const table = new Table(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");
   }
 }
 
@@ -267,6 +212,20 @@ export function getGlobalArgumentHelpEntry(
         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) {
@@ -399,6 +358,21 @@ function getOptionHelpEntry(
       }
     }
   }
+  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: ${
@@ -480,6 +454,20 @@ function getPositionalHelpEntry(
         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");
@@ -633,7 +621,7 @@ export function getMultiCommandAppSyntax(
   let argOptional = false;
   let argValueOptional = false;
   let multipleArg = false;
-  const commandClauses = [];
+  const commandClauses: string[] = [];
   if (globalCommands.length > 0) {
     commandClauses.push(`<${globalPrefix}command>`);
     arg = globalCommands.some((
@@ -749,3 +737,31 @@ export function getMultiCommandAppSyntax(
   }
   return syntax;
 }
+
+export function findPossibleCommandNames(
+  commandName: string,
+  groupCommands: ReadonlyArray<GroupCommand>,
+  subCommands: ReadonlyArray<SubCommand>,
+): string[] {
+  const levenCommandArray = new Array<[number, string]>();
+  subCommands.forEach((subCommand) => {
+    levenCommandArray.push([
+      distance(subCommand.name, commandName),
+      subCommand.name,
+    ]);
+  });
+  groupCommands.forEach((groupCommand) => {
+    groupCommand.memberSubCommands.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/src/util/logger.ts

@@ -86,9 +86,11 @@ function wrapDefaultLogger(
  * @returns A logger instance with the specified name.
  */
 export default function getLogger(loggerName: string): Logger {
-  if (globalThis.defaultLogger === undefined) {
-    globalThis.defaultLogger = getDefaultLogger();
+  const g = globalThis as Record<string, unknown>;
+  if (g.defaultLogger === undefined) {
+    g.defaultLogger = getDefaultLogger();
   }
+  const defaultLogger = g.defaultLogger as Logger;
 
   if (loggerName.length > maxLoggerNameLength) {
     maxLoggerNameLength = loggerName.length;
@@ -108,28 +110,28 @@ export default function getLogger(loggerName: string): Logger {
     return {
       trace: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.TRACE,
-        globalThis.defaultLogger.trace,
+        LEVEL_PADDINGS.TRACE!,
+        defaultLogger.trace,
       ),
       debug: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.DEBUG,
-        globalThis.defaultLogger.debug,
+        LEVEL_PADDINGS.DEBUG!,
+        defaultLogger.debug,
       ),
       info: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.INFO,
-        globalThis.defaultLogger.info,
+        LEVEL_PADDINGS.INFO!,
+        defaultLogger.info,
       ),
       warn: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.WARN,
-        globalThis.defaultLogger.warn,
+        LEVEL_PADDINGS.WARN!,
+        defaultLogger.warn,
       ),
       error: wrapDefaultLogger(
         loggerName,
-        LEVEL_PADDINGS.ERROR,
-        globalThis.defaultLogger.error,
+        LEVEL_PADDINGS.ERROR!,
+        defaultLogger.error,
       ),
     };
   }
@@ -140,8 +142,8 @@ export default function getLogger(loggerName: string): Logger {
     warn: () => {},
     error: wrapDefaultLogger(
       loggerName,
-      LEVEL_PADDINGS.ERROR,
-      globalThis.defaultLogger.error,
+      LEVEL_PADDINGS.ERROR!,
+      defaultLogger.error,
     ),
   };
 }

package/src/util/runnerHelper.ts

@@ -10,6 +10,8 @@ import {
 } from "../runtime/command/CommandTypeGuards.ts";
 import type Context from "../api/Context.ts";
 import { getInvalidArgumentString } from "../runtime/values/argumentValueValidation.ts";
+import type CommandRegistry from "../runtime/registry/CommandRegistry.ts";
+import { findPossibleCommandNames } from "./helpHelper.ts";
 
 function getCommandString(
   printerService: PrinterService,
@@ -91,6 +93,45 @@ export async function printNoCommandSpecifiedError(context: Context) {
   await printerService.error("No command specified\n\n");
 }
 
+export async function printNoCommandRecognisedError(
+  context: Context,
+  commandRegistry: CommandRegistry,
+  availableArgs: ReadonlyArray<string>,
+) {
+  const printerService = context.getServiceById(
+    PRINTER_SERVICE_ID,
+  ) as PrinterService;
+  await printerService.error("No command recognised\n\n");
+
+  if (availableArgs.length > 0) {
+    const groupCommands = commandRegistry.getGroupCommands();
+    const subCommands = commandRegistry.getSubCommands();
+
+    const allPossibleCommandNames: string[] = [];
+    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: Context,
   overallUnusedArgs: ReadonlyArray<string>,