@flowscripter/dynamic-cli-framework 2.4.0 → 3.0.0

package/src/service/upgrade/DefaultUpgradeService.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type {
   CLIConfig,
-  ShutdownService,
+  FetchService,
   SpawnResult,
   SpawnService,
   UpgradeCheckResult,
@@ -40,7 +40,7 @@ const OS_LABELS: Record<SupportedOs, string> = {
 
 export default class DefaultUpgradeService implements UpgradeService {
   #spawnService: SpawnService | undefined;
-  #shutdownService: ShutdownService | undefined;
+  #fetchService: FetchService | undefined;
   #upgradeCheckPromise: Promise<UpgradeCheckResult | undefined> | undefined;
   readonly #config: UpgradeLocationsConfig;
   readonly #cliConfig: CLIConfig;
@@ -50,9 +50,12 @@ export default class DefaultUpgradeService implements UpgradeService {
     this.#cliConfig = cliConfig;
   }
 
-  public setDependencies(spawnService: SpawnService, shutdownService?: ShutdownService): void {
+  public setDependencies(
+    spawnService: SpawnService | undefined,
+    fetchService: FetchService | undefined,
+  ): void {
     this.#spawnService = spawnService;
-    this.#shutdownService = shutdownService;
+    this.#fetchService = fetchService;
   }
 
   public getUpgradeCheckResult(waitForResult = false): Promise<UpgradeCheckResult | undefined> {
@@ -170,6 +173,9 @@ export default class DefaultUpgradeService implements UpgradeService {
     if (!this.#spawnService) {
       return { ok: false, oldVersion, error: new Error("SpawnService is not available") };
     }
+    if (checkResult.installMethod === InstallMethod.GITHUB_RELEASE && !this.#fetchService) {
+      return { ok: false, oldVersion, error: new Error("FetchService is not available") };
+    }
 
     try {
       switch (checkResult.installMethod) {
@@ -204,7 +210,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["brew", "list", "--versions", this.#config.homebrew.formula],
-      { stdio: "wrapped", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
     );
     return result.ok;
   }
@@ -215,7 +221,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     }
     const result = await this.#spawnService.spawn(
       ["winget", "list", "--id", this.#config.winget.packageId],
-      { stdio: "wrapped", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
+      { mode: "ignore", longRunning: false, timeoutMs: VERSION_CHECK_TIMEOUT_MS },
     );
     return result.ok;
   }
@@ -239,14 +245,14 @@ export default class DefaultUpgradeService implements UpgradeService {
   }
 
   async #getLatestGithubReleaseVersion(): Promise<string | undefined> {
-    if (!this.#config.githubRelease) {
+    if (!this.#config.githubRelease || !this.#fetchService) {
       return undefined;
     }
     const { owner, repo } = this.#config.githubRelease;
     try {
-      const response = await fetch(
+      const response = await this.#fetchService.fetch(
         `https://api.github.com/repos/${owner}/${repo}/releases/latest`,
-        { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) },
+        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -260,7 +266,7 @@ export default class DefaultUpgradeService implements UpgradeService {
   }
 
   async #getLatestHomebrewVersion(): Promise<string | undefined> {
-    if (!this.#config.homebrew) {
+    if (!this.#config.homebrew || !this.#fetchService) {
       return undefined;
     }
     const { tap, formula } = this.#config.homebrew;
@@ -269,9 +275,9 @@ export default class DefaultUpgradeService implements UpgradeService {
       return undefined;
     }
     try {
-      const response = await fetch(
+      const response = await this.#fetchService.fetch(
         `https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`,
-        { signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS) },
+        { timeoutMs: VERSION_CHECK_TIMEOUT_MS },
       );
       if (!response.ok) {
         return undefined;
@@ -292,7 +298,7 @@ export default class DefaultUpgradeService implements UpgradeService {
     const result = await this.#spawnService.spawn(
       ["winget", "show", "--id", this.#config.winget.packageId],
       {
-        stdio: "wrapped",
+        mode: "wrapped",
         longRunning: false,
         timeoutMs: VERSION_CHECK_TIMEOUT_MS,
         onOutput: (line) => lines.push(line),
@@ -312,7 +318,9 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaLinuxScript(): Promise<void> {
     const { scriptUrl } = this.#config.linuxScript!;
-    const result = await this.#spawnService!.spawn(["sh", "-c", `curl -fsSL ${scriptUrl} | sh`]);
+    const result = await this.#spawnService!.spawn(["sh", "-c", `curl -fsSL ${scriptUrl} | sh`], {
+      mode: "ignore",
+    });
     if (!result.ok) {
       throw new Error(`Install script failed: ${describeSpawnFailure(result)}`);
     }
@@ -320,7 +328,9 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaHomebrew(): Promise<void> {
     const { tap, formula } = this.#config.homebrew!;
-    const result = await this.#spawnService!.spawn(["brew", "upgrade", `${tap}/${formula}`]);
+    const result = await this.#spawnService!.spawn(["brew", "upgrade", `${tap}/${formula}`], {
+      mode: "ignore",
+    });
     if (!result.ok) {
       throw new Error(`brew upgrade failed: ${describeSpawnFailure(result)}`);
     }
@@ -328,15 +338,18 @@ export default class DefaultUpgradeService implements UpgradeService {
 
   async #upgradeViaWinget(): Promise<void> {
     const { packageId } = this.#config.winget!;
-    const result = await this.#spawnService!.spawn([
-      "winget",
-      "upgrade",
-      "--id",
-      packageId,
-      "--silent",
-      "--accept-package-agreements",
-      "--accept-source-agreements",
-    ]);
+    const result = await this.#spawnService!.spawn(
+      [
+        "winget",
+        "upgrade",
+        "--id",
+        packageId,
+        "--silent",
+        "--accept-package-agreements",
+        "--accept-source-agreements",
+      ],
+      { mode: "ignore" },
+    );
     if (!result.ok) {
       throw new Error(`winget upgrade failed: ${describeSpawnFailure(result)}`);
     }
@@ -349,19 +362,13 @@ export default class DefaultUpgradeService implements UpgradeService {
     const assetName = assetPattern.replace("{os}", OS_LABELS[os]).replace("{arch}", archLabel);
     const url = `https://github.com/${owner}/${repo}/releases/latest/download/${assetName}`;
 
-    // Downloading the release asset but enter long-running mode to get cooperative
-    // Ctrl-C handling during what can be the slowest step of the upgrade.
-    this.#shutdownService?.enterLongRunningMode();
-    let archiveData: ArrayBuffer;
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`Failed to download release asset '${assetName}': HTTP ${response.status}`);
-      }
-      archiveData = await response.arrayBuffer();
-    } finally {
-      this.#shutdownService?.leaveLongRunningMode();
+    // longRunning: true gets cooperative Ctrl-C handling during what can be the slowest step of
+    // the upgrade.
+    const response = await this.#fetchService!.fetch(url, { longRunning: true });
+    if (!response.ok) {
+      throw new Error(`Failed to download release asset '${assetName}': HTTP ${response.status}`);
     }
+    const archiveData = await response.arrayBuffer();
 
     const tmpDir = await mkdtemp(join(tmpdir(), "upgrade-"));
     const archivePath = join(tmpDir, assetName);
@@ -370,52 +377,46 @@ export default class DefaultUpgradeService implements UpgradeService {
     const currentExecutable = process.execPath;
 
     if (os === SupportedOs.WINDOWS) {
-      const extractResult = await this.#spawnService!.spawn([
-        "powershell",
-        "-Command",
-        `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
-      ]);
+      const extractResult = await this.#spawnService!.spawn(
+        [
+          "powershell",
+          "-Command",
+          `Expand-Archive -Path '${archivePath}' -DestinationPath '${tmpDir}' -Force`,
+        ],
+        { mode: "ignore" },
+      );
       if (!extractResult.ok) {
         throw new Error("Failed to extract release archive");
       }
       const extractedBinary = join(tmpDir, `${this.#cliConfig.name}.exe`);
       const oldPath = `${currentExecutable}.old.exe`;
-      const moveResult = await this.#spawnService!.spawn([
-        "cmd",
-        "/c",
-        "move",
-        "/y",
-        currentExecutable,
-        oldPath,
-      ]);
+      const moveResult = await this.#spawnService!.spawn(
+        ["cmd", "/c", "move", "/y", currentExecutable, oldPath],
+        { mode: "ignore" },
+      );
       if (!moveResult.ok) {
         throw new Error("Failed to move current executable aside");
       }
-      const copyResult = await this.#spawnService!.spawn([
-        "cmd",
-        "/c",
-        "copy",
-        "/y",
-        extractedBinary,
-        currentExecutable,
-      ]);
+      const copyResult = await this.#spawnService!.spawn(
+        ["cmd", "/c", "copy", "/y", extractedBinary, currentExecutable],
+        { mode: "ignore" },
+      );
       if (!copyResult.ok) {
         throw new Error("Failed to copy new executable into place");
       }
     } else {
-      const extractResult = await this.#spawnService!.spawn([
-        "unzip",
-        "-o",
-        archivePath,
-        "-d",
-        tmpDir,
-      ]);
+      const extractResult = await this.#spawnService!.spawn(
+        ["unzip", "-o", archivePath, "-d", tmpDir],
+        {
+          mode: "ignore",
+        },
+      );
       if (!extractResult.ok) {
         throw new Error("Failed to extract release archive");
       }
       const extractedBinary = join(tmpDir, this.#cliConfig.name);
       await Bun.write(currentExecutable, Bun.file(extractedBinary));
-      await this.#spawnService!.spawn(["chmod", "+x", currentExecutable]);
+      await this.#spawnService!.spawn(["chmod", "+x", currentExecutable], { mode: "ignore" });
     }
   }
 }

package/src/service/upgrade/UpgradeServiceProvider.ts

@@ -8,8 +8,8 @@ import { KEY_VALUE_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { KeyValueService } from "@flowscripter/dynamic-cli-framework-api";
 import { SPAWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { SpawnService } from "@flowscripter/dynamic-cli-framework-api";
-import { SHUTDOWN_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
-import type { ShutdownService } from "@flowscripter/dynamic-cli-framework-api";
+import { FETCH_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
+import type { FetchService } from "@flowscripter/dynamic-cli-framework-api";
 import { Icon, PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
 import DefaultUpgradeService from "./DefaultUpgradeService.ts";
@@ -44,15 +44,19 @@ export default class UpgradeServiceProvider implements ServiceProvider {
     const upgradeService = this.#upgradeService!;
     const cliConfig = this.#cliConfig!;
 
-    if (context.doesServiceExist(SPAWN_SERVICE_ID)) {
-      const spawnService = context.getServiceById(SPAWN_SERVICE_ID) as SpawnService;
-      const shutdownService = context.doesServiceExist(SHUTDOWN_SERVICE_ID)
-        ? (context.getServiceById(SHUTDOWN_SERVICE_ID) as ShutdownService)
-        : undefined;
-      upgradeService.setDependencies(spawnService, shutdownService);
-    } else {
+    const spawnService = context.doesServiceExist(SPAWN_SERVICE_ID)
+      ? (context.getServiceById(SPAWN_SERVICE_ID) as SpawnService)
+      : undefined;
+    const fetchService = context.doesServiceExist(FETCH_SERVICE_ID)
+      ? (context.getServiceById(FETCH_SERVICE_ID) as FetchService)
+      : undefined;
+    if (spawnService === undefined) {
       logger.debug(() => "SpawnService not available, upgrade install methods will be unavailable");
     }
+    if (fetchService === undefined) {
+      logger.debug(() => "FetchService not available, upgrade version checks will be unavailable");
+    }
+    upgradeService.setDependencies(spawnService, fetchService);
 
     void upgradeService.getUpgradeCheckResult();
 

package/src/service/upgrade/command/UpgradeSubCommand.ts

@@ -1,10 +1,7 @@
 import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  type ArgumentValues,
-  ArgumentValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { type Values, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import {
   Icon,
   InstallMethod,
@@ -24,14 +21,14 @@ export class UpgradeSubCommand implements SubCommand {
   readonly options: ReadonlyArray<Option> = [
     {
       name: "os",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       isOptional: true,
       allowableValues: Object.values(SupportedOs),
       description: "Override the detected operating system",
     },
     {
       name: "install-method",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       isOptional: true,
       allowableValues: Object.values(InstallMethod),
       description: "Override the detected install method",
@@ -44,7 +41,7 @@ export class UpgradeSubCommand implements SubCommand {
     this.#upgradeService = upgradeService;
   }
 
-  public async execute(context: Context, argumentValues: ArgumentValues): Promise<void> {
+  public async execute(context: Context, argumentValues: Values): Promise<void> {
     const printerService = context.getServiceById(PRINTER_SERVICE_ID) as PrinterService;
     const cliName = context.cliConfig.name;
 

package/src/util/envVarHelper.ts

@@ -2,10 +2,10 @@ import process from "node:process";
 import type { Command } from "@flowscripter/dynamic-cli-framework-api";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 import {
-  ArgumentValueTypeName,
+  ValueTypeName,
   ComplexValueTypeName,
-  type PopulatedArgumentSingleValueType,
-  type PopulatedArgumentValues,
+  type PopulatedSingleValueType,
+  type PopulatedValues,
 } from "@flowscripter/dynamic-cli-framework-api";
 type ProcessEnv = NodeJS.ProcessEnv;
 
@@ -59,7 +59,7 @@ function getGlobalArgumentKeyPrefix(
 export function getGlobalCommandValueFromEnvVars(
   cliConfig: CLIConfig,
   command: GlobalCommand,
-): PopulatedArgumentSingleValueType {
+): PopulatedSingleValueType {
   const { argument } = command;
   if (argument === undefined) {
     return undefined;
@@ -67,7 +67,7 @@ export function getGlobalCommandValueFromEnvVars(
 
   // simple check for a specific env var name
   let envVarValue = process.env[getGlobalArgumentKeyPrefix(cliConfig, command, argument)];
-  if (envVarValue != undefined && argument.type === ArgumentValueTypeName.BOOLEAN) {
+  if (envVarValue != undefined && argument.type === ValueTypeName.BOOLEAN) {
     envVarValue = envVarValue.length > 0 ? "true" : "false";
   }
 
@@ -75,7 +75,7 @@ export function getGlobalCommandValueFromEnvVars(
 }
 
 function getOptionValuesFromEnvVars(
-  envVarValues: PopulatedArgumentValues,
+  envVarValues: PopulatedValues,
   potentialEnvVarNames: Array<string>,
   env: ProcessEnv,
   option: Option | ComplexOption,
@@ -126,17 +126,16 @@ function getOptionValuesFromEnvVars(
         if (suffix.length > 0) {
           if (option.type === ComplexValueTypeName.COMPLEX) {
             if (
-              (envVarValues[option.name] as Array<PopulatedArgumentSingleValueType>)[index] ===
-              undefined
+              (envVarValues[option.name] as Array<PopulatedSingleValueType>)[index] === undefined
             ) {
-              (envVarValues[option.name] as Array<PopulatedArgumentValues>)[index] = Object.create(
+              (envVarValues[option.name] as Array<PopulatedValues>)[index] = Object.create(
                 null,
-              ) as PopulatedArgumentValues;
+              ) as PopulatedValues;
             }
             (option as ComplexOption).properties.forEach((property) => {
               const propertySegment = property.configurationKey || getKeySegment(property.name);
               getOptionValuesFromEnvVars(
-                (envVarValues[option.name] as Array<PopulatedArgumentValues>)[index]!,
+                (envVarValues[option.name] as Array<PopulatedValues>)[index]!,
                 matches,
                 env,
                 property,
@@ -145,13 +144,13 @@ function getOptionValuesFromEnvVars(
             });
             if (
               Object.keys(
-                (envVarValues[option.name] as Array<PopulatedArgumentValues>)[index] as Record<
+                (envVarValues[option.name] as Array<PopulatedValues>)[index] as Record<
                   string,
                   string
                 >,
               ).length === 0
             ) {
-              delete (envVarValues[option.name] as Array<PopulatedArgumentValues>)[index];
+              delete (envVarValues[option.name] as Array<PopulatedValues>)[index];
             }
           } else {
             throw new Error(`Unidentified suffix ${suffix} in env var: ${match}`);
@@ -161,14 +160,13 @@ function getOptionValuesFromEnvVars(
         } else {
           // set primitive value
           let envVarValue = env[match];
-          if (envVarValue != undefined && option.type === ArgumentValueTypeName.BOOLEAN) {
+          if (envVarValue != undefined && option.type === ValueTypeName.BOOLEAN) {
             envVarValue = envVarValue.length > 1 ? "true" : "false";
           }
-          (envVarValues[option.name] as Array<PopulatedArgumentSingleValueType>)[index] =
-            envVarValue;
+          (envVarValues[option.name] as Array<PopulatedSingleValueType>)[index] = envVarValue;
         }
 
-        const elements = envVarValues[option.name] as Array<PopulatedArgumentSingleValueType>;
+        const elements = envVarValues[option.name] as Array<PopulatedSingleValueType>;
         for (let i = elements.length - 1; i > -1; i--) {
           if (elements[i] === undefined) {
             elements.length = i;
@@ -182,11 +180,11 @@ function getOptionValuesFromEnvVars(
   } else if (option.type === ComplexValueTypeName.COMPLEX) {
     (option as ComplexOption).properties.forEach((property) => {
       if (envVarValues[option.name] === undefined) {
-        envVarValues[option.name] = Object.create(null) as PopulatedArgumentValues;
+        envVarValues[option.name] = Object.create(null) as PopulatedValues;
       }
       const propertySegment = property.configurationKey || getKeySegment(property.name);
       getOptionValuesFromEnvVars(
-        envVarValues[option.name] as PopulatedArgumentValues,
+        envVarValues[option.name] as PopulatedValues,
         potentialEnvVarNames,
         env,
         property,
@@ -202,7 +200,7 @@ function getOptionValuesFromEnvVars(
     if (value === undefined) {
       return undefined;
     }
-    if (option.type === ArgumentValueTypeName.BOOLEAN) {
+    if (option.type === ValueTypeName.BOOLEAN) {
       value = value.length > 1 ? "true" : "false";
     }
     // set primitive value
@@ -220,8 +218,8 @@ function getOptionValuesFromEnvVars(
 export function getSubCommandValuesFromEnvVars(
   cliConfig: CLIConfig,
   command: SubCommand,
-): PopulatedArgumentValues | undefined {
-  const envVarValues = Object.create(null) as PopulatedArgumentValues;
+): PopulatedValues | undefined {
+  const envVarValues = Object.create(null) as PopulatedValues;
   if (command.options) {
     for (const option of command.options) {
       const potentialEnvVarNames = Object.keys(process.env);
@@ -270,11 +268,10 @@ export function getSubCommandValuesFromEnvVars(
             }
             // set primitive value
             let envVarValue = process.env[match];
-            if (envVarValue != undefined && positional.type === ArgumentValueTypeName.BOOLEAN) {
+            if (envVarValue != undefined && positional.type === ValueTypeName.BOOLEAN) {
               envVarValue = envVarValue.length > 1 ? "true" : "false";
             }
-            (envVarValues[positional.name] as Array<PopulatedArgumentSingleValueType>)[index] =
-              envVarValue;
+            (envVarValues[positional.name] as Array<PopulatedSingleValueType>)[index] = envVarValue;
           }
         });
       } else {
@@ -283,7 +280,7 @@ export function getSubCommandValuesFromEnvVars(
         if (value === undefined) {
           return undefined;
         }
-        if (positional.type === ArgumentValueTypeName.BOOLEAN) {
+        if (positional.type === ValueTypeName.BOOLEAN) {
           value = value.length > 1 ? "true" : "false";
         }
         // set primitive value

package/src/util/helpHelper.ts

@@ -1,10 +1,7 @@
 import { distance } from "fastest-levenshtein";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  ArgumentValueTypeName,
-  ComplexValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { ValueTypeName, ComplexValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { UsageExample } from "@flowscripter/dynamic-cli-framework-api";
@@ -144,24 +141,21 @@ function getGlobalCommandArgumentForm(globalCommandArgument: GlobalCommandArgume
   let argumentSyntax = "";
 
   switch (globalCommandArgument.type) {
-    case ArgumentValueTypeName.BOOLEAN:
+    case ValueTypeName.BOOLEAN:
       argumentSyntax = "true|false";
       break;
-    case ArgumentValueTypeName.INTEGER:
+    case ValueTypeName.INTEGER:
       argumentSyntax = "<integer_value>";
       break;
-    case ArgumentValueTypeName.NUMBER:
+    case ValueTypeName.NUMBER:
       argumentSyntax = "<number_value>";
       break;
-    case ArgumentValueTypeName.STRING:
+    case ValueTypeName.STRING:
       argumentSyntax = "<string_value>";
       break;
   }
 
-  if (
-    globalCommandArgument.isOptional ||
-    globalCommandArgument.type === ArgumentValueTypeName.BOOLEAN
-  ) {
+  if (globalCommandArgument.isOptional || globalCommandArgument.type === ValueTypeName.BOOLEAN) {
     argumentSyntax = `[${argumentSyntax}]`;
   }
 
@@ -187,13 +181,13 @@ export function getGlobalArgumentHelpEntry(
     notesItems.push(`valid values: ${argument.allowableValues.join("|")}`);
   } else {
     switch (argument.type) {
-      case ArgumentValueTypeName.STRING:
+      case ValueTypeName.STRING:
         notesItems.push("string value");
         break;
-      case ArgumentValueTypeName.INTEGER:
+      case ValueTypeName.INTEGER:
         notesItems.push("integer value");
         break;
-      case ArgumentValueTypeName.NUMBER:
+      case ValueTypeName.NUMBER:
         notesItems.push("number value");
         break;
     }
@@ -240,17 +234,17 @@ export function getSubCommandArgumentsSyntax(subCommand: SubCommand): string {
 
   subCommand.options.forEach((option) => {
     let optionSyntax = `--${option.name}`;
-    switch (option.type as ArgumentValueTypeName | ComplexValueTypeName) {
-      case ArgumentValueTypeName.BOOLEAN:
+    switch (option.type as ValueTypeName | ComplexValueTypeName) {
+      case ValueTypeName.BOOLEAN:
         optionSyntax = `${optionSyntax} [true|false]`;
         break;
-      case ArgumentValueTypeName.INTEGER:
+      case ValueTypeName.INTEGER:
         optionSyntax = `${optionSyntax} <integer_value>`;
         break;
-      case ArgumentValueTypeName.NUMBER:
+      case ValueTypeName.NUMBER:
         optionSyntax = `${optionSyntax} <number_value>`;
         break;
-      case ArgumentValueTypeName.STRING:
+      case ValueTypeName.STRING:
         optionSyntax = `${optionSyntax} <string_value>`;
         break;
       case ComplexValueTypeName.COMPLEX:
@@ -318,16 +312,16 @@ function getOptionHelpEntry(
       notesItems.push(`valid values: ${option.allowableValues.join("|")}`);
     } else {
       switch (option.type) {
-        case ArgumentValueTypeName.STRING:
+        case ValueTypeName.STRING:
           notesItems.push(`string value`);
           break;
-        case ArgumentValueTypeName.INTEGER:
+        case ValueTypeName.INTEGER:
           notesItems.push(`integer value`);
           break;
-        case ArgumentValueTypeName.NUMBER:
+        case ValueTypeName.NUMBER:
           notesItems.push(`number value`);
           break;
-        case ArgumentValueTypeName.BOOLEAN:
+        case ValueTypeName.BOOLEAN:
           notesItems.push(`boolean value`);
           break;
       }
@@ -403,16 +397,16 @@ function getPositionalHelpEntry(
     notesItems.push(`valid values: ${positional.allowableValues.join("|")}`);
   } else {
     switch (positional.type) {
-      case ArgumentValueTypeName.STRING:
+      case ValueTypeName.STRING:
         notesItems.push(`string value`);
         break;
-      case ArgumentValueTypeName.INTEGER:
+      case ValueTypeName.INTEGER:
         notesItems.push(`integer value`);
         break;
-      case ArgumentValueTypeName.NUMBER:
+      case ValueTypeName.NUMBER:
         notesItems.push(`number value`);
         break;
-      case ArgumentValueTypeName.BOOLEAN:
+      case ValueTypeName.BOOLEAN:
         notesItems.push(`boolean value`);
         break;
     }
@@ -544,7 +538,7 @@ export function getMultiCommandAppSyntax(
           modifier.argument !== undefined &&
           !modifier.argument.isOptional &&
           modifier.argument.defaultValue === undefined &&
-          modifier.argument.type !== ArgumentValueTypeName.BOOLEAN,
+          modifier.argument.type !== ValueTypeName.BOOLEAN,
       );
       syntax += optionArgMandatory ? " <value>" : " [<value>]";
     }
@@ -571,7 +565,7 @@ export function getMultiCommandAppSyntax(
       argValueOptional = globalCommands.some(
         (globalCommand) =>
           globalCommand.argument !== undefined &&
-          globalCommand.argument.type === ArgumentValueTypeName.BOOLEAN,
+          globalCommand.argument.type === ValueTypeName.BOOLEAN,
       );
     }
   }
@@ -623,19 +617,17 @@ export function getMultiCommandAppSyntax(
           groupCommand.memberSubCommands.some((memberCommand) =>
             memberCommand.options.some(
               (option) =>
-                option.type === ArgumentValueTypeName.BOOLEAN ||
+                option.type === ValueTypeName.BOOLEAN ||
                 memberCommand.positionals.some(
-                  (positional) => positional.type === ArgumentValueTypeName.BOOLEAN,
+                  (positional) => positional.type === ValueTypeName.BOOLEAN,
                 ),
             ),
           ),
         ) ||
         subCommands.some(
           (subCommand) =>
-            subCommand.options.some((option) => option.type === ArgumentValueTypeName.BOOLEAN) ||
-            subCommand.positionals.some(
-              (positional) => positional.type === ArgumentValueTypeName.BOOLEAN,
-            ),
+            subCommand.options.some((option) => option.type === ValueTypeName.BOOLEAN) ||
+            subCommand.positionals.some((positional) => positional.type === ValueTypeName.BOOLEAN),
         );
       multipleArg =
         multipleArg ||