@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

package/src/launcher.ts

@@ -1,33 +1,20 @@
 import process from "node:process";
 import path from "node:path";
 import type CLIConfig from "./api/CLIConfig.ts";
+import type BaseCLIFeatureOptions from "./api/BaseCLIFeatureOptions.ts";
 import type SubCommand from "./api/command/SubCommand.ts";
 import DefaultRuntimeCLI from "./cli/DefaultRuntimeCLI.ts";
 import type Command from "./api/command/Command.ts";
 import type RunResult from "./api/RunResult.ts";
 import type { ServiceProvider } from "./api/service/ServiceProvider.ts";
 
-/**
- * Launch a {@link DefaultRuntimeCLI} with a single specified {@link SubCommand} instance.
- *
- * @param command the {@link SubCommand} to add to the CLI.
- * @param description optional description of the CLI.
- * @param name optional name of the CLI. If not provided, `process.execPath` will be used in an attempt to derive the name.
- * @param version optional version of the CLI.
- * @param envVarsEnabled optionally support checking env variables for default argument values.
- * @param configEnabled optionally enable configuration file support for default argument values.
- * @param keyValueServiceEnabled optionally provide a {@link KeyValueService} implementation: `configEnabled` must be true in this case
- * @param serviceProviders optional array of {@link ServiceProvider} instances to add to the CLI.
- */
 export async function launchSingleCommandCLI(
   command: SubCommand,
   description?: string,
   name?: string,
   version?: string,
-  envVarsEnabled = false,
-  configEnabled = false,
-  keyValueServiceEnabled = false,
   serviceProviders?: ReadonlyArray<ServiceProvider>,
+  options?: BaseCLIFeatureOptions,
 ): Promise<RunResult> {
   if (!name) {
     name = path.basename(process.execPath);
@@ -38,20 +25,12 @@ export async function launchSingleCommandCLI(
     version: version || "N/A",
   };
 
-  if (!configEnabled && keyValueServiceEnabled) {
-    throw new Error(
-      "configEnabled must be true if keyValueServiceEnabled is true",
-    );
-  }
-  const validateAllCommands =
-    process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined;
-  const cli = new DefaultRuntimeCLI(
-    cliConfig,
-    envVarsEnabled,
-    configEnabled,
-    keyValueServiceEnabled,
-    validateAllCommands,
-  );
+  const mergedOptions: BaseCLIFeatureOptions = {
+    ...options,
+    validateAllCommands: (options?.validateAllCommands ?? false) ||
+      process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined,
+  };
+  const cli = new DefaultRuntimeCLI(cliConfig, mergedOptions);
 
   cli.addCommand(command);
 
@@ -60,27 +39,13 @@ export async function launchSingleCommandCLI(
   return await cli.run();
 }
 
-/**
- * Launch a {@link DefaultRuntimeCLI} with multiple specified {@link Command} instances.
- *
- * @param commands the {@link Command} instances to add to the CLI.
- * @param description optional description of the CLI.
- * @param name optional name of the CLI. If not provided, `process.execPath` will be used in an attempt to derive the name.
- * @param version optional version of the CLI.
- * @param envVarsEnabled optionally support checking env variables for default argument values.
- * @param configEnabled optionally enable configuration file support for default argument values.
- * @param keyValueServiceEnabled optionally provide a {@link KeyValueService} implementation: `configEnabled` must be true in this case
- * @param serviceProviders optional array of {@link ServiceProvider} instances to add to the CLI.
- */
 export async function launchMultiCommandCLI(
   commands: ReadonlyArray<Command>,
   description?: string,
   name?: string,
   version?: string,
-  envVarsEnabled = false,
-  configEnabled = false,
-  keyValueServiceEnabled = false,
   serviceProviders?: ReadonlyArray<ServiceProvider>,
+  options?: BaseCLIFeatureOptions,
 ): Promise<RunResult> {
   if (!name) {
     name = path.basename(process.execPath);
@@ -90,20 +55,13 @@ export async function launchMultiCommandCLI(
     name,
     version: version || "N/A",
   };
-  if (!configEnabled && keyValueServiceEnabled) {
-    throw new Error(
-      "configEnabled must be true if keyValueServiceEnabled is true",
-    );
-  }
-  const validateAllCommands =
-    process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined;
-  const cli = new DefaultRuntimeCLI(
-    cliConfig,
-    envVarsEnabled,
-    configEnabled,
-    keyValueServiceEnabled,
-    validateAllCommands,
-  );
+
+  const mergedOptions: BaseCLIFeatureOptions = {
+    ...options,
+    validateAllCommands: (options?.validateAllCommands ?? false) ||
+      process.env.DYNAMIC_CLI_FRAMEWORK_VALIDATE_ALL !== undefined,
+  };
+  const cli = new DefaultRuntimeCLI(cliConfig, mergedOptions);
 
   commands.forEach((command) => cli.addCommand(command));
 

package/src/runtime/command/CommandValidator.ts

@@ -98,7 +98,7 @@ function isNameLegal(name: string): boolean {
 function isConfigurationKeyLegal(configurationKey: string): boolean {
   return (configurationKey.length > 0) &&
     isUppercaseAlphaNumericOrUnderscore(configurationKey) &&
-    !configurationKey[0].match(/[0-9]/);
+    !configurationKey[0]!.match(/[0-9]/);
 }
 
 function validateArgument(argument: Argument, name: string): void {
@@ -368,7 +368,7 @@ export default class CommandValidator {
     }
     if (subCommand.positionals) {
       for (let i = 0; i < subCommand.positionals.length; i += 1) {
-        const positional = subCommand.positionals[i];
+        const positional = subCommand.positionals[i]!;
         validateSubCommandArgument(positional);
         if (argumentNames.includes(positional.name)) {
           throw new Error(
@@ -396,7 +396,7 @@ export default class CommandValidator {
     command: Command,
     argumentAncestry: Array<SubCommandArgument>,
   ) {
-    const argument = argumentAncestry[argumentAncestry.length - 1];
+    const argument = argumentAncestry[argumentAncestry.length - 1]!;
     if (command.enableConfiguration === true) {
       if (
         (argument.configurationKey !== undefined) &&

package/src/runtime/runner.ts

@@ -33,9 +33,35 @@ import type GroupCommand from "../api/command/GroupCommand.ts";
 import type SubCommand from "../api/command/SubCommand.ts";
 import type GlobalCommand from "../api/command/GlobalCommand.ts";
 import type Command from "../api/command/Command.ts";
+import type ArgumentPrompterService from "../api/service/core/ArgumentPrompterService.ts";
+import { ARGUMENT_PROMPTER_SERVICE_ID } from "../api/service/core/ArgumentPrompterService.ts";
 
 const logger = getLogger("runner");
 
+async function attemptPromptForMissingArguments(
+  parseResult: ParseResult,
+  context: Context,
+): Promise<ParseResult | undefined> {
+  if (!context.doesServiceExist(ARGUMENT_PROMPTER_SERVICE_ID)) {
+    return undefined;
+  }
+  const service = context.getServiceById(
+    ARGUMENT_PROMPTER_SERVICE_ID,
+  ) as ArgumentPrompterService;
+  try {
+    const updated = await service.promptForMissingArguments(parseResult);
+    if (updated.invalidArguments.length === 0) {
+      return updated;
+    }
+  } catch (error) {
+    if ((error as Error).message === "Interrupted") {
+      throw error;
+    }
+    return undefined;
+  }
+  return undefined;
+}
+
 /**
  * Execute the {@link Command} with arguments contained in the provided {@link ParseResult}.
  *
@@ -56,13 +82,19 @@ async function executeParsedCommand(
         "Executing group command with name: %s",
         parseResult!.groupCommand!.name,
       );
-      if (configurationServiceProvider?.keyValueServiceEnabled) {
+      if (
+        configurationServiceProvider?.keyValueServiceEnabled ||
+        configurationServiceProvider?.secretServiceEnabled
+      ) {
         configurationServiceProvider.setCommandKeyValueScope(
           parseResult!.groupCommand!.name,
         );
       }
       await parseResult.groupCommand.execute(context);
-      if (configurationServiceProvider?.keyValueServiceEnabled) {
+      if (
+        configurationServiceProvider?.keyValueServiceEnabled ||
+        configurationServiceProvider?.secretServiceEnabled
+      ) {
         await configurationServiceProvider.clearKeyValueScope();
       }
     }
@@ -73,7 +105,10 @@ async function executeParsedCommand(
       parseResult!.populatedArgumentValues,
     );
 
-    if (configurationServiceProvider?.keyValueServiceEnabled) {
+    if (
+      configurationServiceProvider?.keyValueServiceEnabled ||
+      configurationServiceProvider?.secretServiceEnabled
+    ) {
       configurationServiceProvider.setCommandKeyValueScope(
         parseResult.command.name,
       );
@@ -89,10 +124,16 @@ async function executeParsedCommand(
         parseResult.populatedArgumentValues as ArgumentSingleValueType,
       );
     }
-    if (configurationServiceProvider?.keyValueServiceEnabled) {
+    if (
+      configurationServiceProvider?.keyValueServiceEnabled ||
+      configurationServiceProvider?.secretServiceEnabled
+    ) {
       await configurationServiceProvider.clearKeyValueScope();
     }
   } catch (err) {
+    if ((err as Error).message === "Interrupted") {
+      throw err;
+    }
     await printCommandExecutionError(
       context,
       parseResult,
@@ -155,7 +196,7 @@ async function findAndExecuteGlobalModifierCommands(
     ) {
       // parse and fast fail on error
       const defaultArgumentValues = configurationServiceProvider
-        ? configurationServiceProvider
+        ? await configurationServiceProvider
           .getDefaultArgumentValues(
             context.cliConfig,
             globalModifierCommandClause.command,
@@ -195,7 +236,7 @@ async function findAndExecuteGlobalModifierCommands(
   for (const globalModifierCommand of remainingGlobalModifierCommands) {
     // if there is a config entry run this by default even though no arguments were provided on the command line
     const defaultArgumentValues = configurationServiceProvider
-      ? configurationServiceProvider
+      ? await configurationServiceProvider
         .getDefaultArgumentValues(context.cliConfig, globalModifierCommand)
       : undefined;
 
@@ -274,7 +315,7 @@ async function findAndExecuteNonModifierCommand(
 
   if (scanResult.nonModifierCommandClause) {
     const defaultArgumentValues = configurationServiceProvider
-      ? configurationServiceProvider
+      ? await configurationServiceProvider
         .getDefaultArgumentValues(
           context.cliConfig,
           scanResult.nonModifierCommandClause.command,
@@ -294,12 +335,20 @@ async function findAndExecuteNonModifierCommand(
     }
 
     if (parseResult.invalidArguments.length > 0) {
-      await printParseResultError(context, parseResult);
-      return {
-        runState: RunState.PARSE_ERROR,
-        command: parseResult.command,
-        invalidArguments: parseResult.invalidArguments,
-      };
+      const prompted = await attemptPromptForMissingArguments(
+        parseResult,
+        context,
+      );
+      if (prompted) {
+        parseResult = prompted;
+      } else {
+        await printParseResultError(context, parseResult);
+        return {
+          runState: RunState.PARSE_ERROR,
+          command: parseResult.command,
+          invalidArguments: parseResult.invalidArguments,
+        };
+      }
     }
 
     // add any unused args back to the list of still unused args
@@ -311,7 +360,7 @@ async function findAndExecuteNonModifierCommand(
     for (const nonModifierCommand of nonModifierCommandsByName.values()) {
       // if there is a config entry run this by default even though no arguments were provided on the command line
       const defaultArgumentValues = configurationServiceProvider
-        ? configurationServiceProvider
+        ? await configurationServiceProvider
           .getDefaultArgumentValues(context.cliConfig, nonModifierCommand)
         : undefined;
 
@@ -329,12 +378,20 @@ async function findAndExecuteNonModifierCommand(
         }
 
         if (parseResult.invalidArguments.length > 0) {
-          await printParseResultError(context, parseResult);
-          return {
-            runState: RunState.PARSE_ERROR,
-            command: parseResult.command,
-            invalidArguments: parseResult.invalidArguments,
-          };
+          const prompted = await attemptPromptForMissingArguments(
+            parseResult,
+            context,
+          );
+          if (prompted) {
+            parseResult = prompted;
+          } else {
+            await printParseResultError(context, parseResult);
+            return {
+              runState: RunState.PARSE_ERROR,
+              command: parseResult.command,
+              invalidArguments: parseResult.invalidArguments,
+            };
+          }
         }
 
         break;
@@ -376,7 +433,7 @@ async function findAndExecuteDefaultNonModifierCommand(
   context: Context,
 ): Promise<RunResult | undefined> {
   const defaultArgumentValues = configurationServiceProvider
-    ? configurationServiceProvider
+    ? await configurationServiceProvider
       .getDefaultArgumentValues(context.cliConfig, defaultNonModifierCommand)
     : undefined;
   const isGlobal = isGlobalCommand(defaultNonModifierCommand);
@@ -448,14 +505,23 @@ async function findAndExecuteDefaultNonModifierCommand(
     }
   }
 
-  // if there were invalid arguments, treat this as the error
+  // if there were invalid arguments, attempt prompting before treating as error
   if (lastErroneousParseResult) {
-    await printParseResultError(context, lastErroneousParseResult, true);
-    return {
-      runState: RunState.PARSE_ERROR,
-      command: defaultNonModifierCommand,
-      invalidArguments: lastErroneousParseResult.invalidArguments,
-    };
+    const prompted = await attemptPromptForMissingArguments(
+      lastErroneousParseResult,
+      context,
+    );
+    if (prompted) {
+      parseResult = prompted;
+      lastErroneousParseResult = undefined;
+    } else {
+      await printParseResultError(context, lastErroneousParseResult, true);
+      return {
+        runState: RunState.PARSE_ERROR,
+        command: defaultNonModifierCommand,
+        invalidArguments: lastErroneousParseResult.invalidArguments,
+      };
+    }
   }
 
   // give up if still nothing found
@@ -604,14 +670,20 @@ export async function run(
 
     logger.debug("Initialising service with ID: %s", serviceProvider.serviceId);
 
-    if (configurationServiceProvider?.keyValueServiceEnabled) {
+    if (
+      configurationServiceProvider?.keyValueServiceEnabled ||
+      configurationServiceProvider?.secretServiceEnabled
+    ) {
       configurationServiceProvider.setServiceKeyValueScope(
         serviceProvider.serviceId,
       );
     }
 
     await serviceProvider.initService(context);
-    if (configurationServiceProvider?.keyValueServiceEnabled) {
+    if (
+      configurationServiceProvider?.keyValueServiceEnabled ||
+      configurationServiceProvider?.secretServiceEnabled
+    ) {
       await configurationServiceProvider.clearKeyValueScope();
     }
   }

package/src/runtime/scanner.ts

@@ -67,15 +67,15 @@ function normaliseFirstArgumentIfRequired(
   // --<global_[modifier_]command_name>=<value>
   // -<global_[modifier_]command_short_alias>
   // -<global_[modifier_]command_short_alias>=<value>
-  if ((firstArg.length < 2) || (firstArg.charAt(0) !== "-")) {
+  if ((firstArg!.length < 2) || (firstArg!.charAt(0) !== "-")) {
     return args;
   }
 
   // looking for:
   // --<global_[modifier_]command_name>
   // --<global_[modifier_]command_name>=<value>
-  if ((firstArg.length > 2) && (firstArg.charAt(1) === "-")) {
-    let potentialGlobalCommandName = firstArg.slice(2);
+  if ((firstArg!.length > 2) && (firstArg!.charAt(1) === "-")) {
+    let potentialGlobalCommandName = firstArg!.slice(2);
 
     // looking for:
     // <global_command_name>=<value>
@@ -84,7 +84,7 @@ function normaliseFirstArgumentIfRequired(
     if (potentialGlobalCommandName.includes("=")) {
       [potentialGlobalCommandName, nextArg] = potentialGlobalCommandName.split(
         /=(.*)/,
-      );
+      ) as [string, string | undefined];
     }
 
     if (!globalCommandsByName.has(potentialGlobalCommandName)) {
@@ -105,14 +105,17 @@ function normaliseFirstArgumentIfRequired(
   // -<global_[modifier_]command_short_alias>
   // -<global_[modifier_]command_short_alias>=<value>
   // (by now we know the arg starts with -<char>)
-  let potentialGlobalCommandShortAlias = firstArg.slice(1);
+  let potentialGlobalCommandShortAlias = firstArg!.slice(1);
 
   // looking for:
   // <global_[modifier_]command_short_alias>=<value>
   let nextArg: string | undefined;
   if (potentialGlobalCommandShortAlias.includes("=")) {
     [potentialGlobalCommandShortAlias, nextArg] =
-      potentialGlobalCommandShortAlias.split(/=(.*)/);
+      potentialGlobalCommandShortAlias.split(/=(.*)/) as [
+        string,
+        string | undefined,
+      ];
   }
 
   if (!globalCommandsByShortAlias) {
@@ -169,8 +172,8 @@ function scanForNextCommandClause(
 
     // looking for:
     // <global_[modifier_]command_name>
-    if (currentArg.startsWith("--")) {
-      const potentialCommandName = currentArg.slice(2);
+    if (currentArg!.startsWith("--")) {
+      const potentialCommandName = currentArg!.slice(2);
 
       // check for Global[Modifier]Command name
       const command = commandsByName.get(potentialCommandName);
@@ -188,8 +191,8 @@ function scanForNextCommandClause(
         };
       }
     }
-    if (!includeSubCommands || (currentArg[0] === "-")) {
-      unusedArgs.push(currentArg);
+    if (!includeSubCommands || (currentArg![0] === "-")) {
+      unusedArgs.push(currentArg!);
       continue;
     }
 
@@ -202,11 +205,11 @@ function scanForNextCommandClause(
       let potentialMemberSubCommandName: string | undefined;
       let potentialMemberCommandNameArgumentUsed = false;
 
-      if (potentialGroupCommandName.includes(":")) {
+      if (potentialGroupCommandName!.includes(":")) {
         // looking for:
         // <group_command_name>:<member_sub_command_name>
         [potentialGroupCommandName, potentialMemberSubCommandName] =
-          potentialGroupCommandName.split(":");
+          potentialGroupCommandName!.split(":") as [string, string | undefined];
       } else if (pendingArgs.length > 0) {
         // looking for:
         // <group_command_name> <member_sub_command_name>
@@ -250,9 +253,9 @@ function scanForNextCommandClause(
     //
     // if we find it is a group command we skip it as we didn't find a member command
     // following it the logic above
-    const command = commandsByName.get(currentArg);
+    const command = commandsByName.get(currentArg!);
     if (command && !isGroupCommand(command)) {
-      logger.debug("Found sub-command name: %s", currentArg);
+      logger.debug("Found sub-command name: %s", currentArg!);
       return {
         commandClause: {
           command,
@@ -263,7 +266,7 @@ function scanForNextCommandClause(
     }
 
     // if we got here we haven't found a command so add the current arg to unused args
-    unusedArgs.push(currentArg);
+    unusedArgs.push(currentArg!);
   }
   // if we got here we haven't found a command and we have processed all provided args
   return {

package/src/runtime/values/argumentValueValidation.ts

@@ -120,7 +120,7 @@ function validatePrimitiveValue(
       (argument.type === ArgumentValueTypeName.STRING) &&
       argument.isCaseInsensitive
     ) {
-      searchValue = convertedValue.toLowerCase();
+      searchValue = (convertedValue as string).toLowerCase();
       allowableValues = argument.allowableValues.map((v) =>
         (v as string).toLowerCase()
       );
@@ -136,7 +136,7 @@ function validatePrimitiveValue(
     }
   }
   if (argument.minValueInclusive !== undefined) {
-    if (convertedValue < argument.minValueInclusive) {
+    if ((convertedValue as number) < argument.minValueInclusive) {
       return {
         invalidArgument: {
           argument,
@@ -148,7 +148,7 @@ function validatePrimitiveValue(
   }
 
   if (argument.maxValueInclusive !== undefined) {
-    if (convertedValue > argument.maxValueInclusive) {
+    if ((convertedValue as number) > argument.maxValueInclusive) {
       return {
         invalidArgument: {
           argument,
@@ -275,7 +275,7 @@ function validateObjectValue(
   const convertedObjectValue: ArgumentValues = {};
 
   for (let i = 0; i < argument.properties.length; i++) {
-    const propertyArg = argument.properties[i];
+    const propertyArg = argument.properties[i]!;
     const propertyValue = objectValue[propertyArg.name];
 
     if (propertyValue === undefined) {
@@ -306,7 +306,10 @@ function validateObjectValue(
           },
         };
       }
-      validationResult = validateArrayValue(propertyArg, propertyValue);
+      validationResult = validateArrayValue(
+        propertyArg as ComplexOption | SubCommandArgument,
+        propertyValue,
+      );
     } else if (typeof propertyValue === "object") {
       if (propertyArg.type !== ComplexValueTypeName.COMPLEX) {
         return {
@@ -468,6 +471,24 @@ function doSubCommandArgumentValidation(
       invalidArguments.push(validationResult.invalidArgument);
       return undefined;
     }
+    if (argument.validate && validationResult.validValue !== undefined) {
+      const customError = argument.validate(
+        validationResult.validValue as
+          | ArgumentValueType
+          | ArgumentValues
+          | Array<ArgumentValues>,
+      );
+      if (customError !== undefined) {
+        invalidArguments.push({
+          argument,
+          name: argument.name,
+          value: validationResult.validValue as PopulatedArgumentValueType,
+          reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+          message: customError,
+        });
+        return undefined;
+      }
+    }
     return validationResult.validValue as
       | PopulatedArgumentValueType
       | PopulatedArgumentValues
@@ -574,6 +595,24 @@ export function validateGlobalCommandArgumentValue(
       return undefined;
     }
 
+    if (
+      globalCommandArgument.validate &&
+      validationResult.validValue !== undefined
+    ) {
+      const customError = globalCommandArgument.validate(
+        validationResult.validValue as ArgumentValueType,
+      );
+      if (customError !== undefined) {
+        invalidArguments.push({
+          argument: globalCommandArgument,
+          name: globalCommand.name,
+          value: validationResult.validValue,
+          reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+          message: customError,
+        });
+        return undefined;
+      }
+    }
     return validationResult.validValue as PopulatedArgumentSingleValueType;
   }
 
@@ -641,6 +680,11 @@ export function getInvalidArgumentString(
     case InvalidArgumentReason.OPTION_IS_COMPLEX:
       invalidString = "(specified option is complex)";
       break;
+    case InvalidArgumentReason.CUSTOM_VALIDATION:
+      invalidString = invalidArgument.message
+        ? `(custom validation: ${invalidArgument.message})`
+        : "(custom validation failed)";
+      break;
     default:
       invalidString = "";
       break;

package/src/runtime/values/globalCommandValuePopulation.ts

@@ -49,7 +49,7 @@ export default function populateGlobalCommandValue(
 
     // don't use potentialArg if it cannot be a boolean value...
     if (argument.type === ArgumentValueTypeName.BOOLEAN) {
-      const firstPotentialArgLower = firstPotentialArg.toLowerCase();
+      const firstPotentialArgLower = firstPotentialArg!.toLowerCase();
 
       if (
         (firstPotentialArgLower !== "true") &&

package/src/runtime/values/subCommandValuePopulation.ts

@@ -175,14 +175,14 @@ class ParseContext {
 
     for (let i = 0; i < complexPathElements.length; i++) {
       let arrayIndexString: string | undefined;
-      let complexPathElement = complexPathElements[i];
+      let complexPathElement = complexPathElements[i]!;
 
       // look for array index
       if (complexPathElement.endsWith("]")) {
         [complexPathElement, arrayIndexString] = complexPathElement.slice(
           0,
           complexPathElement.length - 1,
-        ).split("[");
+        ).split("[") as [string, string | undefined];
       }
 
       let lookupPath = this.subCommand.name;
@@ -237,7 +237,7 @@ class ParseContext {
         }
         option = this.optionLookupMapsByPath.get(lookupPath)!.get(
           complexPathElement,
-        );
+        ) as Option | ComplexOption | undefined;
 
         // now we are parsing properties of complex options it is an error if we cannot match an option name or alias
         if (option === undefined) {
@@ -423,8 +423,8 @@ class ParseContext {
         if (typeof pathElement === "string") {
           if (Array.isArray(optionValue)) {
             optionValue = (optionValue as Array<PopulatedArgumentValues>)[
-              optionValue.length - 1
-            ][pathElement as string] as
+              (optionValue as Array<PopulatedArgumentValues>).length - 1
+            ]![pathElement as string] as
               | Array<PopulatedArgumentValues>
               | PopulatedArgumentValues
               | PopulatedArgumentValueType;
@@ -459,7 +459,8 @@ class ParseContext {
    * @param value the value to attempt to set.
    */
   setPositionalValue(value: ArgumentSingleValueType): boolean {
-    const positional = this.subCommand.positionals[this.currentPositionalIndex];
+    const positional = this.subCommand
+      .positionals[this.currentPositionalIndex]!;
     const currentValue = this.populatedArgumentValues[positional.name];
 
     // if we haven't populated the argument value before...
@@ -536,7 +537,7 @@ class ParseContext {
         // check for option AND value
         if (potentialOptionPath.includes("=")) {
           [potentialOptionPath, potentialOptionValue] = potentialOptionPath
-            .split(/=(.*)/);
+            .split(/=(.*)/) as [string, string | undefined, ...string[]];
 
           // check for illegal syntax e.g. --optionName=
           if (potentialOptionValue === "") {
@@ -623,7 +624,7 @@ export default function populateSubCommandValues(
   const unusedArgs: Array<string> = [];
 
   for (let i = 0; i < potentialArgs.length; i++) {
-    const potentialArg = potentialArgs[i];
+    const potentialArg = potentialArgs[i]!;
 
     // parse the next arg
     parseContext.parse(potentialArg);