@flowscripter/dynamic-cli-framework 10.1.1 → 11.1.0

package/src/service/argumentPrompter/DefaultArgumentPrompterService.ts

@@ -14,7 +14,9 @@ import {
   ComplexValueTypeName,
   type PopulatedSingleValueType,
   type PopulatedValues,
+  type Values,
 } from "@flowscripter/dynamic-cli-framework-api";
+import type { Command } from "@flowscripter/dynamic-cli-framework-api";
 import type { Argument } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
@@ -23,6 +25,20 @@ import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
 import { isGlobalCommand, isSubCommand } from "../../runtime/command/CommandTypeGuards.ts";
 
+/**
+ * The command and values visible to {@link Argument.validate} functions while prompting.
+ */
+interface PromptScope {
+  readonly command: Command;
+  readonly values: PopulatedValues | PopulatedSingleValueType;
+}
+
+/**
+ * Used as {@link ValidationContext.command} when prompting via {@link ArgumentPrompterService.promptForArguments},
+ * which is not associated with a specific command.
+ */
+const NO_COMMAND = { name: "" } as Command;
+
 export default class DefaultArgumentPrompterService implements ArgumentPrompterService {
   readonly #prompterService: PrompterService;
 
@@ -63,6 +79,53 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     return parseResult;
   }
 
+  async promptForArguments(
+    args: ReadonlyArray<Option | ComplexOption>,
+    existing: Values = {},
+  ): Promise<Values | undefined> {
+    if (!this.#prompterService.promptEnabled) {
+      return undefined;
+    }
+    const prompted: Record<string, Values[string]> = {};
+    const merged: Record<string, Values[string]> = { ...existing };
+    const scope: PromptScope = { command: NO_COMMAND, values: merged as PopulatedValues };
+
+    for (const arg of args) {
+      if (arg.name in existing) {
+        continue;
+      }
+      const value = (await this.#promptForArgument(arg.name, arg, scope)) as Values[string];
+      prompted[arg.name] = value;
+      merged[arg.name] = value;
+    }
+    return prompted as Values;
+  }
+
+  async #promptForArgument(
+    name: string,
+    arg: Option | Positional | ComplexOption,
+    scope: PromptScope,
+  ): Promise<PopulatedValues[string]> {
+    if ("type" in arg && (arg as ComplexOption).type === ComplexValueTypeName.COMPLEX) {
+      return await this.#promptForComplexOption(name, arg as ComplexOption, scope);
+    }
+    if (DefaultArgumentPrompterService.#isArrayArgument(arg)) {
+      return await this.#promptForArrayArgument(name, arg as Option | Positional, scope);
+    }
+    const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+      name,
+      (arg as Option | Positional).description ?? name,
+      arg as Argument,
+      name,
+      scope,
+    );
+    const result = await this.#prompterService.prompt(prompt);
+    return DefaultArgumentPrompterService.#coerceValue(
+      result.value as SingleValueType,
+      (arg as Argument).type,
+    );
+  }
+
   async #promptForGlobalCommand(parseResult: ParseResult): Promise<ParseResult> {
     const command = parseResult.command as GlobalCommand;
     if (!command.argument) {
@@ -73,6 +136,8 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
       command.name,
       command.name,
       command.argument,
+      command.name,
+      { command, values: undefined },
     );
     const result = await this.#prompterService.prompt(prompt);
     const value = DefaultArgumentPrompterService.#coerceValue(
@@ -96,6 +161,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
       ...existingValues,
     };
     const remainingInvalid: InvalidArgument[] = [];
+    const scope: PromptScope = { command, values: newValues as PopulatedValues };
 
     for (const invalid of parseResult.invalidArguments) {
       if (invalid.reason !== InvalidArgumentReason.MISSING_VALUE || !invalid.name) {
@@ -109,30 +175,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
         continue;
       }
 
-      if ("type" in arg && (arg as ComplexOption).type === ComplexValueTypeName.COMPLEX) {
-        const complexValues = await this.#promptForComplexOption(
-          invalid.name,
-          arg as ComplexOption,
-        );
-        newValues[invalid.name] = complexValues;
-      } else if (DefaultArgumentPrompterService.#isArrayArgument(arg)) {
-        const arrayValues = await this.#promptForArrayArgument(
-          invalid.name,
-          arg as Option | Positional,
-        );
-        newValues[invalid.name] = arrayValues;
-      } else {
-        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
-          invalid.name,
-          (arg as Option | Positional).description ?? invalid.name,
-          arg as Argument,
-        );
-        const result = await this.#prompterService.prompt(prompt);
-        newValues[invalid.name] = DefaultArgumentPrompterService.#coerceValue(
-          result.value as SingleValueType,
-          (arg as Argument).type,
-        );
-      }
+      newValues[invalid.name] = await this.#promptForArgument(invalid.name, arg, scope);
     }
 
     return {
@@ -147,6 +190,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
   async #promptForComplexOption(
     name: string,
     complexOption: ComplexOption,
+    scope: PromptScope,
   ): Promise<PopulatedValues> {
     const values: Record<string, PopulatedValues[string]> = {};
 
@@ -155,6 +199,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
         values[(prop as ComplexOption).name] = await this.#promptForComplexOption(
           `${name}.${(prop as ComplexOption).name}`,
           prop as ComplexOption,
+          scope,
         );
       } else {
         const option = prop as Option;
@@ -165,6 +210,8 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
           `${name}.${option.name}`,
           option.description ?? `${name}.${option.name}`,
           option,
+          `${name}.${option.name}`,
+          scope,
         );
         const result = await this.#prompterService.prompt(prompt);
         values[option.name] = DefaultArgumentPrompterService.#coerceValue(
@@ -180,6 +227,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
   async #promptForArrayArgument(
     name: string,
     arg: Option | Positional,
+    scope: PromptScope,
   ): Promise<Array<SingleValueType>> {
     const values: SingleValueType[] = [];
 
@@ -188,6 +236,8 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
         name,
         `${arg.description ?? name}${values.length > 0 ? ` [${values.length + 1}]` : ""}`,
         arg as Argument,
+        name,
+        scope,
       );
       const result = await this.#prompterService.prompt(prompt);
       values.push(
@@ -212,7 +262,13 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     return values;
   }
 
-  static #argumentToPrompt(name: string, description: string, arg: Argument): Prompt {
+  static #argumentToPrompt(
+    name: string,
+    description: string,
+    arg: Argument,
+    path: string,
+    scope: PromptScope,
+  ): Prompt {
     if (arg.type === ValueTypeName.BOOLEAN) {
       return {
         name,
@@ -240,7 +296,17 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
       returnedValue: "",
       min: arg.minValueInclusive,
       max: arg.maxValueInclusive,
-      validate: arg.validate ? (v) => arg.validate!(v) : undefined,
+      validate: arg.validate
+        ? (v) => {
+            const value = DefaultArgumentPrompterService.#coerceValue(v, arg.type);
+            return arg.validate!(value, {
+              argument: arg,
+              path,
+              values: scope.values === undefined ? value : scope.values,
+              command: scope.command,
+            });
+          }
+        : undefined,
     };
 
     return {

package/src/service/configuration/ConfigurationServiceProvider.ts

@@ -14,7 +14,8 @@ import type {
 import getLogger from "../../util/logger.ts";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
-import DumpConfigCommand from "./command/DumpConfigCommand.ts";
+import ConfigDumpSubCommand from "./command/ConfigDumpSubCommand.ts";
+import ConfigGroupCommand from "./command/ConfigGroupCommand.ts";
 import {
   CONFIGURATION_SERVICE_ID,
   SECRET_SENTINEL_PREFIX,
@@ -63,7 +64,7 @@ class ConfigurationServiceImpl implements ConfigurationService {
  * {@link KeyValueServiceProvider} (which holds a direct reference to this provider - see
  * {@link getKeyValueData} and {@link flushIfDirty} - rather than looking this provider up via
  * {@link Context}, since only {@link configLocation}/{@link setConfigLocation} are safe to expose
- * generally; {@link getConfigString} is wired directly to {@link DumpConfigCommand} for the same
+ * generally; {@link getConfigString} is wired directly to {@link ConfigDumpSubCommand} for the same
  * reason - a full config dump would leak every other command's/service's key-value data if it
  * were reachable through a general lookup).
  *
@@ -222,7 +223,9 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
 
     if (this.configEnabled) {
       commands.push(new ConfigCommand(this.servicePriority));
-      commands.push(new DumpConfigCommand(() => this.getConfigString()));
+      commands.push(
+        new ConfigGroupCommand([new ConfigDumpSubCommand(() => this.getConfigString())]),
+      );
     }
     if (this.secretServiceEnabled) {
       this.#defaultsSecretService = new DefaultSecretService(cliConfig.name, "defaults");

package/src/service/configuration/KeyValueServiceProvider.ts

@@ -226,6 +226,7 @@ export default class KeyValueServiceProvider implements ServiceProvider {
     const scopedKeyValueService = this.getScopedKeyValueService(scopeType, scopeKey);
     return {
       cliConfig: context.cliConfig,
+      isTty: context.isTty,
       getServiceById: (id: string): unknown =>
         id === KEY_VALUE_SERVICE_ID ? scopedKeyValueService : context.getServiceById(id),
       doesServiceExist: (id: string): boolean => context.doesServiceExist(id),

package/src/service/configuration/command/{DumpConfigCommand.ts → ConfigDumpSubCommand.ts}

@@ -1,21 +1,26 @@
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { Option } from "@flowscripter/dynamic-cli-framework-api";
+import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
+import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { PrinterService } from "@flowscripter/dynamic-cli-framework-api";
 import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import type { SyntaxHighlighterService } from "@flowscripter/dynamic-cli-framework-api";
 import { SYNTAX_HIGHLIGHTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 
 /**
- * Command which dumps the configuration loaded by {@link ConfigurationServiceProvider}.
+ * Member of the `config` group which dumps the configuration loaded by
+ * {@link ConfigurationServiceProvider}.
  *
  * Takes a direct reference to {@link ConfigurationServiceProvider.getConfigString}, wired by the
  * provider that constructs this command, rather than looking it up via {@link Context} -
  * deliberately, since a full config dump is not something every command/task should be able to
  * reach through a general lookup (see {@link ConfigurationService}'s doc comment).
  */
-export default class DumpConfigCommand implements GlobalCommand {
-  readonly name = "dump-config";
+export default class ConfigDumpSubCommand implements SubCommand {
+  readonly name = "dump";
   readonly description = "Dump configuration values";
+  readonly options: ReadonlyArray<Option> = [];
+  readonly positionals: ReadonlyArray<Positional> = [];
 
   readonly #getConfigString: () => string;
 

package/src/service/configuration/command/ConfigGroupCommand.ts

@@ -0,0 +1,20 @@
+import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
+
+/**
+ * Group command named `config` whose members manage the configuration handled by
+ * {@link ConfigurationServiceProvider}.
+ */
+export default class ConfigGroupCommand implements GroupCommand {
+  readonly name = "config";
+  readonly description = "Manage configuration";
+  readonly enableConfiguration = false;
+  readonly memberSubCommands: ReadonlyArray<SubCommand>;
+
+  public constructor(memberSubCommands: ReadonlyArray<SubCommand>) {
+    this.memberSubCommands = memberSubCommands;
+  }
+
+  public async execute(_context: Context): Promise<void> {}
+}

package/dist/src/service/configuration/command/DumpConfigCommand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DumpConfigCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/configuration/command/DumpConfigCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAM7E;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAkB,YAAW,aAAa;;IAC7D,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,QAAQ,CAAC,WAAW,+BAA+B;IAInD,YAAmB,eAAe,EAAE,MAAM,MAAM,EAE/C;IAEY,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CASpD;CACF"}