@flowscripter/dynamic-cli-framework 11.0.0 → 11.1.0

package/dist/src/cli/BaseCLI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseCLI.d.ts","sourceRoot":"","sources":["../../../src/cli/BaseCLI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yCAAyC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAU3E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAC;AAqCpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,YAAW,GAAG;;IAazC,YACE,SAAS,EAAE,SAAS,EACpB,oBAAoB,EAAE,cAAc,EACpC,oBAAoB,EAAE,cAAc,EACpC,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,OAAO,EACtB,cAAc,EAAE,QAAQ,EACxB,cAAc,EAAE,QAAQ,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,qBAAqB,EAmEhC;IAED;;;;;;;OAOG;IACI,kBAAkB,CAAC,eAAe,EAAE,eAAe,QAEzD;IAED;;;;;;;;OAQG;IACH;;;;;OAKG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,QAEtC;IAEM,UAAU,CAAC,OAAO,EAAE,OAAO,QAQjC;IAEK,GAAG,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAqQzD;CACF"}
+{"version":3,"file":"BaseCLI.d.ts","sourceRoot":"","sources":["../../../src/cli/BaseCLI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yCAAyC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIzE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAGvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAsBzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAU3E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,SAAS,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAC;AAqCpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,YAAW,GAAG;;IAazC,YACE,SAAS,EAAE,SAAS,EACpB,oBAAoB,EAAE,cAAc,EACpC,oBAAoB,EAAE,cAAc,EACpC,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,OAAO,EACtB,cAAc,EAAE,QAAQ,EACxB,cAAc,EAAE,QAAQ,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,qBAAqB,EAuEhC;IAED;;;;;;;OAOG;IACI,kBAAkB,CAAC,eAAe,EAAE,eAAe,QAEzD;IAED;;;;;;;;OAQG;IACH;;;;;OAKG;IACI,cAAc,CAAC,IAAI,EAAE,WAAW,QAEtC;IAEM,UAAU,CAAC,OAAO,EAAE,OAAO,QAQjC;IAEK,GAAG,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAqQzD;CACF"}

package/dist/src/cli/BaseCLI.js

@@ -130,7 +130,11 @@ export default class BaseCLI {
         // create a command registry
         this.#commandRegistry = new DefaultCommandRegistry([], commandValidator);
         // create a context
-        this.#context = new DefaultContext(this.#cliConfig);
+        this.#context = new DefaultContext(this.#cliConfig, {
+            stdin: keyReader !== undefined,
+            stdout: stdoutTerminal.isTty(),
+            stderr: stderrTerminal.isTty(),
+        });
         this.#startupServiceProvider = new StartupServiceProvider(STARTUP_SERVICE_PRIORITY);
         this.#stdoutTerminal = stdoutTerminal;
         this.#printerService = new DefaultPrinterService(stdoutWritableStream, stderrWritableStream, stdoutIsColor, stderrIsColor, stdoutTerminal, stderrTerminal, styler);
@@ -187,7 +191,7 @@ export default class BaseCLI {
         this.addServiceProvider(this.#startupServiceProvider);
         this.addServiceProvider(new PrinterServiceProvider(PRINTER_SERVICE_PRIORITY, this.#printerService));
         this.addServiceProvider(new TableGeneratorServiceProvider(TABLE_GENERATOR_SERVICE_PRIORITY));
-        const canPrompt = this.#keyReader !== undefined && this.#stderrTerminal.isTty();
+        const canPrompt = this.#context.isTty.stdin && this.#context.isTty.stderr;
         if (this.#options.promptingEnabled && !canPrompt) {
             throw new Error("promptingEnabled requires a keyReader and a TTY stderr terminal");
         }

package/dist/src/runtime/DefaultContext.d.ts

@@ -6,7 +6,8 @@ import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 export default class DefaultContext implements Context {
     #private;
     readonly cliConfig: CLIConfig;
-    constructor(cliConfig: CLIConfig);
+    readonly isTty: Context["isTty"];
+    constructor(cliConfig: CLIConfig, isTty?: Context["isTty"]);
     addServiceInstance(id: string, serviceInstance: unknown): void;
     getServiceById(id: string): unknown;
     doesServiceExist(id: string): boolean;

package/dist/src/runtime/DefaultContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultContext.d.ts","sourceRoot":"","sources":["../../../src/runtime/DefaultContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,OAAO;;IAGjC,QAAQ,CAAC,SAAS,EAAE,SAAS;IAAhD,YAA4B,SAAS,EAAE,SAAS,EAAI;IAE7C,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,QAK7D;IAEM,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAKzC;IAEM,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE3C;CACF"}
+{"version":3,"file":"DefaultContext.d.ts","sourceRoot":"","sources":["../../../src/runtime/DefaultContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,YAAW,OAAO;;IAIlD,QAAQ,CAAC,SAAS,EAAE,SAAS;IAC7B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC;IAFlC,YACW,SAAS,EAAE,SAAS,EACpB,KAAK,GAAE,OAAO,CAAC,OAAO,CAAkD,EAC/E;IAEG,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,QAK7D;IAEM,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAKzC;IAEM,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAE3C;CACF"}

package/dist/src/runtime/DefaultContext.js

@@ -3,9 +3,11 @@
  */
 export default class DefaultContext {
     cliConfig;
+    isTty;
     #serviceInstancesById = new Map();
-    constructor(cliConfig) {
+    constructor(cliConfig, isTty = { stdin: false, stdout: false, stderr: false }) {
         this.cliConfig = cliConfig;
+        this.isTty = isTty;
     }
     addServiceInstance(id, serviceInstance) {
         if (this.#serviceInstancesById.has(id)) {

package/dist/src/runtime/command/CommandValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommandValidator.d.ts","sourceRoot":"","sources":["../../../../src/runtime/command/CommandValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAiBvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmJzE,MAAM,CAAC,OAAO,OAAO,gBAAgB;;IAKnC,YAAmB,SAAS,EAAE,SAAS,EAEtC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAUtC;CAsWF"}
+{"version":3,"file":"CommandValidator.d.ts","sourceRoot":"","sources":["../../../../src/runtime/command/CommandValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAmBvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmJzE,MAAM,CAAC,OAAO,OAAO,gBAAgB;;IAKnC,YAAmB,SAAS,EAAE,SAAS,EAEtC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAUtC;CAkYF"}

package/dist/src/runtime/command/CommandValidator.js

@@ -1,7 +1,7 @@
 import { isGroupCommand, isSubCommand } from "./CommandTypeGuards.js";
 import { ValueTypeName, ComplexValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import { isComplexOption } from "../argument/ArgumentTypeGuards.js";
-import { getInvalidArgumentString, validateGlobalCommandArgumentValue, validateOptionValue, } from "../values/argumentValueValidation.js";
+import { getInvalidArgumentString, validateGlobalCommandArgumentValue, validateOptionValue, runCustomValidation, } from "../values/argumentValueValidation.js";
 import getLogger from "../../util/logger.js";
 import { getGlobalCommandArgumentConfigurationKey, getSubCommandArgumentConfigurationKey, } from "../../util/configHelper.js";
 const logger = getLogger("commandValidation");
@@ -145,7 +145,11 @@ export default class CommandValidator {
             validateArgument(argument, globalCommand.name);
             if (argument.defaultValue) {
                 const invalidArguments = [];
-                validateGlobalCommandArgumentValue(globalCommand, argument.defaultValue, invalidArguments);
+                const deferred = [];
+                validateGlobalCommandArgumentValue(globalCommand, argument.defaultValue, invalidArguments, deferred);
+                if (invalidArguments.length === 0) {
+                    runCustomValidation(deferred, globalCommand, argument.defaultValue, invalidArguments);
+                }
                 if (invalidArguments.length > 0) {
                     throw new Error(`Illegal default value for global command: '${globalCommand.name}' => ${invalidArguments
                         .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))
@@ -303,18 +307,22 @@ export default class CommandValidator {
             ]);
         }
         else {
-            this.#validateOption(option, currentOptionPaths, allOptionPaths);
+            this.#validateOption(subCommand, option, currentOptionPaths, allOptionPaths);
             this.#validateSubCommandArgumentConfigurationKey(subCommand, [...argumentAncestry, option]);
         }
     }
-    #validateOption(option, currentOptionPaths, allOptionPaths) {
+    #validateOption(subCommand, option, currentOptionPaths, allOptionPaths) {
         validateSubCommandArgument(option);
         if (Array.isArray(option.defaultValue) && !option.isArray) {
             throw new Error(`Illegal array default value: '${option.defaultValue.join(",")}' for non-array option: '${option.name}'`);
         }
         if (option.defaultValue) {
             const invalidArguments = [];
-            validateOptionValue(option, option.defaultValue, invalidArguments);
+            const deferred = [];
+            validateOptionValue(option, option.defaultValue, invalidArguments, deferred);
+            if (invalidArguments.length === 0) {
+                runCustomValidation(deferred, subCommand, { [option.name]: option.defaultValue }, invalidArguments);
+            }
             if (invalidArguments.length > 0) {
                 throw new Error(`Illegal default value for option: '${option.name}' => ${invalidArguments
                     .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))
@@ -350,7 +358,11 @@ export default class CommandValidator {
         }
         if (complexOption.defaultValue) {
             const invalidArguments = [];
-            validateOptionValue(complexOption, complexOption.defaultValue, invalidArguments);
+            const deferred = [];
+            validateOptionValue(complexOption, complexOption.defaultValue, invalidArguments, deferred);
+            if (invalidArguments.length === 0) {
+                runCustomValidation(deferred, subCommand, { [complexOption.name]: complexOption.defaultValue }, invalidArguments);
+            }
             if (invalidArguments.length > 0) {
                 throw new Error(`Illegal default value for option: '${complexOption.name}' => ${invalidArguments
                     .map((invalidArgument) => getInvalidArgumentString(invalidArgument, true))

package/dist/src/runtime/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/runtime/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAelD,YAAY,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG;IACjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,aAAa,EAC5B,aAAa,CAAC,EAAE,eAAe,GAC9B,sBAAsB,CAiFxB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,EAC5B,YAAY,CAAC,EAAE,wBAAwB,GACtC,sBAAsB,CAwDxB"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/runtime/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAiBlD,YAAY,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG;IACjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,aAAa,EAC5B,aAAa,CAAC,EAAE,eAAe,GAC9B,sBAAsB,CAwFxB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,EAC5B,YAAY,CAAC,EAAE,wBAAwB,GACtC,sBAAsB,CA6DxB"}

package/dist/src/runtime/parser.js

@@ -1,5 +1,5 @@
 import populateGlobalCommandValue from "./values/globalCommandValuePopulation.js";
-import { validateGlobalCommandArgumentValue, validateOptionValue, validatePositionalValue, } from "./values/argumentValueValidation.js";
+import { validateGlobalCommandArgumentValue, validateOptionValue, validatePositionalValue, runCustomValidation, } from "./values/argumentValueValidation.js";
 import getLogger from "../util/logger.js";
 import { redactGlobalCommandValue, redactSubCommandValues } from "../util/secretRedaction.js";
 import populateSubCommandValues from "./values/subCommandValuePopulation.js";
@@ -30,9 +30,10 @@ export function parseSubCommandClause(commandClause, defaultValues) {
         invalidArguments.push(invalidArgument);
     }
     if (invalidArguments.length === 0) {
+        const deferred = [];
         // validate the option values
         command.options.forEach((option) => {
-            const validatedValue = validateOptionValue(option, populatedArgumentValues[option.name] || option.defaultValue, invalidArguments);
+            const validatedValue = validateOptionValue(option, populatedArgumentValues[option.name] || option.defaultValue, invalidArguments, deferred);
             if (validatedValue !== undefined) {
                 populatedArgumentValues[option.name] = validatedValue;
             }
@@ -41,11 +42,15 @@ export function parseSubCommandClause(commandClause, defaultValues) {
         if (invalidArguments.length === 0) {
             // validate the positional values
             command.positionals.forEach((positional) => {
-                const validatedValue = validatePositionalValue(positional, populatedArgumentValues[positional.name], invalidArguments);
+                const validatedValue = validatePositionalValue(positional, populatedArgumentValues[positional.name], invalidArguments, deferred);
                 if (validatedValue !== undefined) {
                     populatedArgumentValues[positional.name] = validatedValue;
                 }
             });
+            if (invalidArguments.length === 0) {
+                // custom validators run once all built-in validation has passed and see all values
+                runCustomValidation(deferred, command, populatedArgumentValues, invalidArguments);
+            }
             logger.debug("Command arguments after positionals validated: %O with invalid args: %O", redactSubCommandValues(command, populatedArgumentValues), invalidArguments);
         }
     }
@@ -94,10 +99,14 @@ export function parseGlobalCommandClause(commandClause, defaultValue) {
     logger.debug("Command arguments for command: %s after value population: %O with invalid args: %O and unused args: %O", command.name, redactGlobalCommandValue(command, populatedArgumentValue), invalidArguments, unusedArgs);
     // don't validate the value if the argument is already invalid
     if (invalidArguments.length === 0) {
-        const validatedValue = validateGlobalCommandArgumentValue(command, populatedArgumentValue, invalidArguments);
+        const deferred = [];
+        const validatedValue = validateGlobalCommandArgumentValue(command, populatedArgumentValue, invalidArguments, deferred);
         if (validatedValue !== undefined) {
             populatedArgumentValue = validatedValue;
         }
+        if (invalidArguments.length === 0) {
+            runCustomValidation(deferred, command, populatedArgumentValue, invalidArguments);
+        }
     }
     logger.debug("Command arguments for command: %s after value validation: %O with invalid args: %O", command.name, redactGlobalCommandValue(command, populatedArgumentValue), invalidArguments);
     return {

package/dist/src/runtime/values/argumentValueValidation.d.ts

@@ -1,25 +1,46 @@
-import type { PopulatedSingleValueType, PopulatedValues, PopulatedValueType } from "@flowscripter/dynamic-cli-framework-api";
+import type { SingleValueType, Values, PopulatedSingleValueType, PopulatedValues, PopulatedValueType } from "@flowscripter/dynamic-cli-framework-api";
 import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { ComplexOption } from "@flowscripter/dynamic-cli-framework-api";
 import type { InvalidArgument } from "@flowscripter/dynamic-cli-framework-api";
+import type { Argument } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { Command } from "@flowscripter/dynamic-cli-framework-api";
+/**
+ * A custom validation to be invoked once all built-in validation has passed.
+ */
+export interface DeferredCustomValidation {
+    readonly argument: Argument | ComplexOption;
+    readonly path: string;
+    readonly value: SingleValueType | Values | Array<SingleValueType | Values>;
+}
+/**
+ * Invokes the recorded custom validations in order, stopping at the first failure.
+ *
+ * @param deferred the validations recorded while validating the values of the command.
+ * @param command the {@link Command} the validated values belong to.
+ * @param values all validated and converted values of the command.
+ * @param invalidArguments an array of {@link InvalidArgument} which is added to if a custom validation fails.
+ */
+export declare function runCustomValidation(deferred: ReadonlyArray<DeferredCustomValidation>, command: Command, values: PopulatedValues | PopulatedSingleValueType, invalidArguments: Array<InvalidArgument>): void;
 /**
  * Validates the provided value against the provided {@link Option}.
  *
  * @param option the {@link Option} to validate against.
  * @param value the value (if any) for the {@link Option}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export declare function validateOptionValue(option: Option | ComplexOption, value: PopulatedValueType | PopulatedValues | Array<PopulatedValues | undefined>, invalidArguments: Array<InvalidArgument>): PopulatedValueType | PopulatedValues | Array<PopulatedValues>;
+export declare function validateOptionValue(option: Option | ComplexOption, value: PopulatedValueType | PopulatedValues | Array<PopulatedValues | undefined>, invalidArguments: Array<InvalidArgument>, deferred?: Array<DeferredCustomValidation>): PopulatedValueType | PopulatedValues | Array<PopulatedValues>;
 /**
  * Validates the provided value against the provided {@link Positional}.
  *
  * @param positional the {@link Positional} to validate against.
  * @param value the value (if any) for the {@link Positional}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export declare function validatePositionalValue(positional: Positional, value: PopulatedValueType, invalidArguments: Array<InvalidArgument>): PopulatedValueType;
+export declare function validatePositionalValue(positional: Positional, value: PopulatedValueType, invalidArguments: Array<InvalidArgument>, deferred?: Array<DeferredCustomValidation>): PopulatedValueType;
 /**
  * Validates the provided value against the {@link GlobalCommandArgument} provided by the {@link GlobalCommand} and returns the validated
  * value or undefined if the value was invalid.
@@ -27,7 +48,8 @@ export declare function validatePositionalValue(positional: Positional, value: P
  * @param globalCommand the {@link GlobalCommand} providing the {@link GlobalCommandArgument}.
  * @param value the value (if any) for the {@link GlobalCommandArgument}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export declare function validateGlobalCommandArgumentValue(globalCommand: GlobalCommand, value: PopulatedSingleValueType, invalidArguments: Array<InvalidArgument>): PopulatedSingleValueType;
+export declare function validateGlobalCommandArgumentValue(globalCommand: GlobalCommand, value: PopulatedSingleValueType, invalidArguments: Array<InvalidArgument>, deferred?: Array<DeferredCustomValidation>): PopulatedSingleValueType;
 export declare function getInvalidArgumentString(invalidArgument: InvalidArgument, skipArgName: boolean): string;
 //# sourceMappingURL=argumentValueValidation.d.ts.map

package/dist/src/runtime/values/argumentValueValidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"argumentValueValidation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/argumentValueValidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAI/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAgb7E;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,aAAa,EAC9B,KAAK,EAAE,kBAAkB,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,GAAG,SAAS,CAAC,EAChF,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,GACvC,kBAAkB,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC,CAQ/D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,kBAAkB,EACzB,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,GACvC,kBAAkB,CAQpB;AAED;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,wBAAwB,EAC/B,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,GACvC,wBAAwB,CA+C1B;AAED,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,OAAO,GACnB,MAAM,CA+DR"}
+{"version":3,"file":"argumentValueValidation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/argumentValueValidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,MAAM,EAEN,wBAAwB,EACxB,eAAe,EACf,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAG/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yCAAyC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAyBvE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CAAC;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG,MAAM,CAAC,CAAC;CAC5E;AAiBD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,aAAa,CAAC,wBAAwB,CAAC,EACjD,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,GAAG,wBAAwB,EAClD,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,GACvC,IAAI,CAmBN;AAyXD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,aAAa,EAC9B,KAAK,EAAE,kBAAkB,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,GAAG,SAAS,CAAC,EAChF,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,EACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,GACzC,kBAAkB,GAAG,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC,CAS/D;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,kBAAkB,EACzB,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,EACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,GACzC,kBAAkB,CASpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,wBAAwB,EAC/B,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,EACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,wBAAwB,CAAC,GACzC,wBAAwB,CA4C1B;AAED,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,OAAO,GACnB,MAAM,CA+DR"}

package/dist/src/runtime/values/argumentValueValidation.js

@@ -8,28 +8,41 @@ function withPrefix(invalidArgument, prefix) {
     return { ...invalidArgument, name: `${prefix}${invalidArgument.name ?? ""}` };
 }
 /**
- * Invokes the custom validate function (if any) of the provided {@link Argument} and returns an
- * {@link InvalidArgument} if the custom validation failed.
- *
- * @param argument the {@link Argument} providing the custom validate function.
- * @param name the name to use for the {@link InvalidArgument}.
- * @param value the validated and type-converted value.
+ * Records a custom validation of the provided {@link Argument} (if it has one) for later invocation by
+ * {@link runCustomValidation}. Deferred validations are recorded bottom-up and depth-first.
  */
-function doCustomValidation(argument, name, value) {
-    if (argument.validate === undefined) {
-        return undefined;
+function deferCustomValidation(deferred, argument, path, value) {
+    if (deferred !== undefined && argument.validate !== undefined) {
+        deferred.push({ argument, path, value });
     }
-    const message = argument.validate(value);
-    if (message === undefined) {
-        return undefined;
+}
+/**
+ * Invokes the recorded custom validations in order, stopping at the first failure.
+ *
+ * @param deferred the validations recorded while validating the values of the command.
+ * @param command the {@link Command} the validated values belong to.
+ * @param values all validated and converted values of the command.
+ * @param invalidArguments an array of {@link InvalidArgument} which is added to if a custom validation fails.
+ */
+export function runCustomValidation(deferred, command, values, invalidArguments) {
+    for (const { argument, path, value } of deferred) {
+        const message = argument.validate(value, {
+            argument: argument,
+            path,
+            values,
+            command,
+        });
+        if (message !== undefined) {
+            invalidArguments.push({
+                argument,
+                name: path,
+                value: value,
+                reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+                message,
+            });
+            return;
+        }
     }
-    return {
-        argument,
-        name,
-        value: value,
-        reason: InvalidArgumentReason.CUSTOM_VALIDATION,
-        message,
-    };
 }
 /**
  * Validates the provided primitive value against the provided {@link Argument}.
@@ -141,7 +154,7 @@ function validatePrimitiveValue(argument, value) {
     }
     return { validValue: convertedValue };
 }
-function validateArrayValue(subCommandArgument, arrayValue) {
+function validateArrayValue(subCommandArgument, arrayValue, path, deferred) {
     const convertedArrayValue = [];
     for (let i = 0; i < arrayValue.length; i += 1) {
         const singleValue = arrayValue[i];
@@ -171,7 +184,7 @@ function validateArrayValue(subCommandArgument, arrayValue) {
                     },
                 };
             }
-            validationResult = validateObjectValue(subCommandArgument, singleValue);
+            validationResult = validateObjectValue(subCommandArgument, singleValue, `${path}[${i}]`, deferred);
         } // if not array and not object, then must be primitive
         else {
             if (isComplexOption(subCommandArgument)) {
@@ -202,10 +215,11 @@ function validateArrayValue(subCommandArgument, arrayValue) {
         validValue: convertedArrayValue,
     };
 }
-function validateObjectValue(argument, objectValue) {
+function validateObjectValue(argument, objectValue, path, deferred) {
     const convertedObjectValue = {};
     for (let i = 0; i < argument.properties.length; i++) {
         const propertyArg = argument.properties[i];
+        const propertyPath = `${path}.${propertyArg.name}`;
         let propertyValue = objectValue[propertyArg.name];
         if (propertyValue === undefined && propertyArg.defaultValue !== undefined) {
             propertyValue = propertyArg.defaultValue;
@@ -236,7 +250,7 @@ function validateObjectValue(argument, objectValue) {
                     },
                 };
             }
-            validationResult = validateArrayValue(propertyArg, propertyValue);
+            validationResult = validateArrayValue(propertyArg, propertyValue, propertyPath, deferred);
         }
         else if (typeof propertyValue === "object") {
             if (propertyArg.type !== ComplexValueTypeName.COMPLEX) {
@@ -250,7 +264,7 @@ function validateObjectValue(argument, objectValue) {
                     },
                 };
             }
-            validationResult = validateObjectValue(propertyArg, propertyValue);
+            validationResult = validateObjectValue(propertyArg, propertyValue, propertyPath, deferred);
         } // if not array and not object, then must be primitive
         else {
             if (isComplexOption(propertyArg)) {
@@ -276,20 +290,14 @@ function validateObjectValue(argument, objectValue) {
                 invalidArgument: withPrefix(validationResult.invalidArgument, `.${propertyArg.name}`),
             };
         }
-        // custom validation runs only once the property (and any nested properties) passed validation
-        const customInvalidArgument = doCustomValidation(propertyArg, `.${propertyArg.name}`, validationResult.validValue);
-        if (customInvalidArgument !== undefined) {
-            return {
-                validValue: convertedObjectValue,
-                invalidArgument: customInvalidArgument,
-            };
-        }
+        // custom validation is deferred until all built-in validation has passed
+        deferCustomValidation(deferred, propertyArg, propertyPath, validationResult.validValue);
     }
     return {
         validValue: convertedObjectValue,
     };
 }
-function doSubCommandArgumentValidation(argument, value, isArray, isOptional, invalidArguments) {
+function doSubCommandArgumentValidation(argument, value, isArray, isOptional, invalidArguments, deferred) {
     // if there is a value, check if it is valid
     if (value !== undefined) {
         let validationResult;
@@ -303,7 +311,7 @@ function doSubCommandArgumentValidation(argument, value, isArray, isOptional, in
                 });
                 return undefined;
             }
-            validationResult = validateArrayValue(argument, value);
+            validationResult = validateArrayValue(argument, value, argument.name, deferred);
         }
         else if (typeof value === "object") {
             if (!isComplexOption(argument)) {
@@ -315,7 +323,7 @@ function doSubCommandArgumentValidation(argument, value, isArray, isOptional, in
                 });
                 return undefined;
             }
-            validationResult = validateObjectValue(argument, value);
+            validationResult = validateObjectValue(argument, value, argument.name, deferred);
         }
         else {
             if (isComplexOption(argument)) {
@@ -333,11 +341,7 @@ function doSubCommandArgumentValidation(argument, value, isArray, isOptional, in
             invalidArguments.push(withPrefix(validationResult.invalidArgument, argument.name));
             return undefined;
         }
-        const customInvalidArgument = doCustomValidation(argument, argument.name, validationResult.validValue);
-        if (customInvalidArgument !== undefined) {
-            invalidArguments.push(customInvalidArgument);
-            return undefined;
-        }
+        deferCustomValidation(deferred, argument, argument.name, validationResult.validValue);
         return validationResult.validValue;
     }
     // if there is no value, check if it was optional
@@ -356,9 +360,10 @@ function doSubCommandArgumentValidation(argument, value, isArray, isOptional, in
  * @param option the {@link Option} to validate against.
  * @param value the value (if any) for the {@link Option}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export function validateOptionValue(option, value, invalidArguments) {
-    return doSubCommandArgumentValidation(option, value, option.isArray || false, option.isOptional || false, invalidArguments);
+export function validateOptionValue(option, value, invalidArguments, deferred) {
+    return doSubCommandArgumentValidation(option, value, option.isArray || false, option.isOptional || false, invalidArguments, deferred);
 }
 /**
  * Validates the provided value against the provided {@link Positional}.
@@ -366,9 +371,10 @@ export function validateOptionValue(option, value, invalidArguments) {
  * @param positional the {@link Positional} to validate against.
  * @param value the value (if any) for the {@link Positional}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export function validatePositionalValue(positional, value, invalidArguments) {
-    return doSubCommandArgumentValidation(positional, value, positional.isVarargMultiple || false, positional.isVarargOptional || false, invalidArguments);
+export function validatePositionalValue(positional, value, invalidArguments, deferred) {
+    return doSubCommandArgumentValidation(positional, value, positional.isVarargMultiple || false, positional.isVarargOptional || false, invalidArguments, deferred);
 }
 /**
  * Validates the provided value against the {@link GlobalCommandArgument} provided by the {@link GlobalCommand} and returns the validated
@@ -377,8 +383,9 @@ export function validatePositionalValue(positional, value, invalidArguments) {
  * @param globalCommand the {@link GlobalCommand} providing the {@link GlobalCommandArgument}.
  * @param value the value (if any) for the {@link GlobalCommandArgument}.
  * @param invalidArguments an array of {@link InvalidArgument} which may be added to if the provided value is invalid.
+ * @param deferred if provided, custom validations are recorded here for later invocation by {@link runCustomValidation}. If omitted, custom validations are not invoked.
  */
-export function validateGlobalCommandArgumentValue(globalCommand, value, invalidArguments) {
+export function validateGlobalCommandArgumentValue(globalCommand, value, invalidArguments, deferred) {
     // if this function is called it is because the argument is defined
     const globalCommandArgument = globalCommand.argument;
     // if there is a value, check if it is valid
@@ -402,11 +409,7 @@ export function validateGlobalCommandArgumentValue(globalCommand, value, invalid
             }
             return undefined;
         }
-        const customInvalidArgument = doCustomValidation(globalCommandArgument, globalCommand.name, validationResult.validValue);
-        if (customInvalidArgument !== undefined) {
-            invalidArguments.push(customInvalidArgument);
-            return undefined;
-        }
+        deferCustomValidation(deferred, globalCommandArgument, globalCommand.name, validationResult.validValue);
         return validationResult.validValue;
     }
     // if there is no value, check if it was optional

package/dist/src/service/argumentPrompter/DefaultArgumentPrompterService.d.ts

@@ -1,9 +1,13 @@
 import type { ArgumentPrompterService } from "@flowscripter/dynamic-cli-framework-api";
 import type { ParseResult } from "../../runtime/parser.ts";
 import type { PrompterService } from "@flowscripter/dynamic-cli-framework-api";
+import { type Values } from "@flowscripter/dynamic-cli-framework-api";
+import type { Option } from "@flowscripter/dynamic-cli-framework-api";
+import type { ComplexOption } from "@flowscripter/dynamic-cli-framework-api";
 export default class DefaultArgumentPrompterService implements ArgumentPrompterService {
     #private;
     constructor(prompterService: PrompterService);
     promptForMissingArguments(parseResult: ParseResult): Promise<ParseResult>;
+    promptForArguments(args: ReadonlyArray<Option | ComplexOption>, existing?: Values): Promise<Values | undefined>;
 }
 //# sourceMappingURL=DefaultArgumentPrompterService.d.ts.map

package/dist/src/service/argumentPrompter/DefaultArgumentPrompterService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultArgumentPrompterService.d.ts","sourceRoot":"","sources":["../../../../src/service/argumentPrompter/DefaultArgumentPrompterService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAuB/E,MAAM,CAAC,OAAO,OAAO,8BAA+B,YAAW,uBAAuB;;IAGpF,YAAmB,eAAe,EAAE,eAAe,EAElD;IAEK,yBAAyB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CA+B9E;CAkOF"}
+{"version":3,"file":"DefaultArgumentPrompterService.d.ts","sourceRoot":"","sources":["../../../../src/service/argumentPrompter/DefaultArgumentPrompterService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAQ/E,OAAO,EAML,KAAK,MAAM,EACZ,MAAM,yCAAyC,CAAC;AAGjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AAEtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAmB7E,MAAM,CAAC,OAAO,OAAO,8BAA+B,YAAW,uBAAuB;;IAGpF,YAAmB,eAAe,EAAE,eAAe,EAElD;IAEK,yBAAyB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CA+B9E;IAEK,kBAAkB,CACtB,IAAI,EAAE,aAAa,CAAC,MAAM,GAAG,aAAa,CAAC,EAC3C,QAAQ,GAAE,MAAW,GACpB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiB7B;CA8PF"}

package/dist/src/service/argumentPrompter/DefaultArgumentPrompterService.js

@@ -2,6 +2,11 @@ import { PromptType, } from "@flowscripter/dynamic-cli-framework-api";
 import { InvalidArgumentReason } from "@flowscripter/dynamic-cli-framework-api";
 import { ValueTypeName, ComplexValueTypeName, } from "@flowscripter/dynamic-cli-framework-api";
 import { isGlobalCommand, isSubCommand } from "../../runtime/command/CommandTypeGuards.js";
+/**
+ * Used as {@link ValidationContext.command} when prompting via {@link ArgumentPrompterService.promptForArguments},
+ * which is not associated with a specific command.
+ */
+const NO_COMMAND = { name: "" };
 export default class DefaultArgumentPrompterService {
     #prompterService;
     constructor(prompterService) {
@@ -34,12 +39,40 @@ export default class DefaultArgumentPrompterService {
         }
         return parseResult;
     }
+    async promptForArguments(args, existing = {}) {
+        if (!this.#prompterService.promptEnabled) {
+            return undefined;
+        }
+        const prompted = {};
+        const merged = { ...existing };
+        const scope = { command: NO_COMMAND, values: merged };
+        for (const arg of args) {
+            if (arg.name in existing) {
+                continue;
+            }
+            const value = (await this.#promptForArgument(arg.name, arg, scope));
+            prompted[arg.name] = value;
+            merged[arg.name] = value;
+        }
+        return prompted;
+    }
+    async #promptForArgument(name, arg, scope) {
+        if ("type" in arg && arg.type === ComplexValueTypeName.COMPLEX) {
+            return await this.#promptForComplexOption(name, arg, scope);
+        }
+        if (DefaultArgumentPrompterService.#isArrayArgument(arg)) {
+            return await this.#promptForArrayArgument(name, arg, scope);
+        }
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(name, arg.description ?? name, arg, name, scope);
+        const result = await this.#prompterService.prompt(prompt);
+        return DefaultArgumentPrompterService.#coerceValue(result.value, arg.type);
+    }
     async #promptForGlobalCommand(parseResult) {
         const command = parseResult.command;
         if (!command.argument) {
             return parseResult;
         }
-        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(command.name, command.name, command.argument);
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(command.name, command.name, command.argument, command.name, { command, values: undefined });
         const result = await this.#prompterService.prompt(prompt);
         const value = DefaultArgumentPrompterService.#coerceValue(result.value, command.argument.type);
         return {
@@ -57,6 +90,7 @@ export default class DefaultArgumentPrompterService {
             ...existingValues,
         };
         const remainingInvalid = [];
+        const scope = { command, values: newValues };
         for (const invalid of parseResult.invalidArguments) {
             if (invalid.reason !== InvalidArgumentReason.MISSING_VALUE || !invalid.name) {
                 remainingInvalid.push(invalid);
@@ -67,19 +101,7 @@ export default class DefaultArgumentPrompterService {
                 remainingInvalid.push(invalid);
                 continue;
             }
-            if ("type" in arg && arg.type === ComplexValueTypeName.COMPLEX) {
-                const complexValues = await this.#promptForComplexOption(invalid.name, arg);
-                newValues[invalid.name] = complexValues;
-            }
-            else if (DefaultArgumentPrompterService.#isArrayArgument(arg)) {
-                const arrayValues = await this.#promptForArrayArgument(invalid.name, arg);
-                newValues[invalid.name] = arrayValues;
-            }
-            else {
-                const prompt = DefaultArgumentPrompterService.#argumentToPrompt(invalid.name, arg.description ?? invalid.name, arg);
-                const result = await this.#prompterService.prompt(prompt);
-                newValues[invalid.name] = DefaultArgumentPrompterService.#coerceValue(result.value, arg.type);
-            }
+            newValues[invalid.name] = await this.#promptForArgument(invalid.name, arg, scope);
         }
         return {
             command: parseResult.command,
@@ -89,28 +111,28 @@ export default class DefaultArgumentPrompterService {
             unusedArgs: parseResult.unusedArgs,
         };
     }
-    async #promptForComplexOption(name, complexOption) {
+    async #promptForComplexOption(name, complexOption, scope) {
         const values = {};
         for (const prop of complexOption.properties) {
             if ("type" in prop && prop.type === ComplexValueTypeName.COMPLEX) {
-                values[prop.name] = await this.#promptForComplexOption(`${name}.${prop.name}`, prop);
+                values[prop.name] = await this.#promptForComplexOption(`${name}.${prop.name}`, prop, scope);
             }
             else {
                 const option = prop;
                 if (option.isOptional && option.defaultValue !== undefined) {
                     continue;
                 }
-                const prompt = DefaultArgumentPrompterService.#argumentToPrompt(`${name}.${option.name}`, option.description ?? `${name}.${option.name}`, option);
+                const prompt = DefaultArgumentPrompterService.#argumentToPrompt(`${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(result.value, option.type);
             }
         }
         return values;
     }
-    async #promptForArrayArgument(name, arg) {
+    async #promptForArrayArgument(name, arg, scope) {
         const values = [];
         while (true) {
-            const prompt = DefaultArgumentPrompterService.#argumentToPrompt(name, `${arg.description ?? name}${values.length > 0 ? ` [${values.length + 1}]` : ""}`, arg);
+            const prompt = DefaultArgumentPrompterService.#argumentToPrompt(name, `${arg.description ?? name}${values.length > 0 ? ` [${values.length + 1}]` : ""}`, arg, name, scope);
             const result = await this.#prompterService.prompt(prompt);
             values.push(DefaultArgumentPrompterService.#coerceValue(result.value, arg.type));
             const addAnother = {
@@ -126,7 +148,7 @@ export default class DefaultArgumentPrompterService {
         }
         return values;
     }
-    static #argumentToPrompt(name, description, arg) {
+    static #argumentToPrompt(name, description, arg, path, scope) {
         if (arg.type === ValueTypeName.BOOLEAN) {
             return {
                 name,
@@ -152,7 +174,17 @@ export default class DefaultArgumentPrompterService {
             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 {
             name,