cli-forge 1.2.3 → 1.4.0

package/src/lib/internal-cli.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 import {
   ArgvParser,
   EnvOptionConfig,
@@ -22,6 +22,8 @@ import {
   ErrorHandler,
   SDKCommand,
 } from './public-api';
+import type { PromptProvider, PromptOptionConfig } from './prompt-types';
+import { resolvePrompts } from './resolve-prompts';
 import { getCallingFile, getParentPackageJson } from './utils';
 
 /**
@@ -55,7 +57,7 @@ const CLI_FORGE_BRAND = Symbol.for('cli-forge:InternalCLI');
 export class InternalCLI<
   TArgs extends ParsedArgs = ParsedArgs,
   THandlerReturn = void,
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   TChildren = {},
   TParent = undefined
 > implements CLI<TArgs, THandlerReturn, TChildren, TParent>
@@ -122,6 +124,14 @@ export class InternalCLI<
     (cli: any, args: TArgs) => Promise<void> | void
   > = [];
 
+  registeredPromptProviders: PromptProvider[] = [];
+
+  /**
+   * Stores prompt config for each option, keyed by option name.
+   * Set when .option() is called with a `prompt` property.
+   */
+  promptConfigs: Map<string, PromptOptionConfig<any>> = new Map();
+
   /**
    * Set when a `$0` alias replaces the root builder via `.command()`.
    * The $0 builder should only run if no explicit subcommand is given,
@@ -287,7 +297,7 @@ export class InternalCLI<
               CLI<TArgs, THandlerReturn, TChildren, TParent>
             >;
           }
-        : // eslint-disable-next-line @typescript-eslint/ban-types
+        : // eslint-disable-next-line @typescript-eslint/no-empty-object-type
           {}),
     TParent
   > {
@@ -372,8 +382,12 @@ export class InternalCLI<
   option<
     TOption extends string,
     const TOptionConfig extends OptionConfig<any, any, any>
-  >(name: TOption, config: TOptionConfig) {
-    this.parser.option(name, config);
+  >(name: TOption, config: TOptionConfig & { prompt?: PromptOptionConfig<TArgs> }) {
+    const { prompt, ...parserConfig } = config;
+    if (prompt !== undefined) {
+      this.promptConfigs.set(name, prompt);
+    }
+    this.parser.option(name, parserConfig as TOptionConfig);
     // Interface modifies the return type to reflect new params, cast is necessay.... I think 🤔
     return this as any;
   }
@@ -381,8 +395,12 @@ export class InternalCLI<
   positional<
     TOption extends string,
     const TOptionConfig extends OptionConfig<any, any, any>
-  >(name: TOption, config: TOptionConfig) {
-    this.parser.positional(name, config);
+  >(name: TOption, config: TOptionConfig & { prompt?: PromptOptionConfig<TArgs> }) {
+    const { prompt, ...parserConfig } = config;
+    if (prompt !== undefined) {
+      this.promptConfigs.set(name, prompt);
+    }
+    this.parser.positional(name, parserConfig as TOptionConfig);
     // Interface modifies the return type to reflect new params, cast is necessay.... I think 🤔
     return this as any;
   }
@@ -829,6 +847,18 @@ export class InternalCLI<
     return this as unknown as CLI<TArgs, THandlerReturn, TChildren, TParent>;
   }
 
+  withPromptProvider(
+    provider: PromptProvider
+  ): CLI<TArgs, THandlerReturn, TChildren, TParent> {
+    if (!provider.prompt && !provider.promptBatch) {
+      throw new Error(
+        "Prompt provider must implement at least one of 'prompt' or 'promptBatch'"
+      );
+    }
+    this.registeredPromptProviders.push(provider);
+    return this as unknown as CLI<TArgs, THandlerReturn, TChildren, TParent>;
+  }
+
   group(
     labelOrConfigObject:
       | string
@@ -1025,6 +1055,47 @@ export class InternalCLI<
       // seeded with the accumulated values from the discovery loop.
       // The alreadyParsed values ensure proper required-option
       // validation and prevent positional re-consumption.
+
+      // Prompt for missing option values before final validation.
+      // Collect prompt providers from the full command chain.
+      const allPromptProviders: PromptProvider[] = [
+        ...this.registeredPromptProviders,
+      ];
+      const allPromptConfigs = new Map(this.promptConfigs);
+      {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let walkCmd: InternalCLI<any, any, any, any> = this;
+        for (const command of this.commandChain) {
+          walkCmd = walkCmd.registeredCommands[command];
+          for (const p of walkCmd.registeredPromptProviders) {
+            allPromptProviders.push(p);
+          }
+          for (const [k, v] of walkCmd.promptConfigs) {
+            allPromptConfigs.set(k, v);
+          }
+        }
+      }
+
+      if (allPromptProviders.length > 0 || allPromptConfigs.size > 0) {
+        const promptedValues = await resolvePrompts({
+          configuredOptions: this.parser.configuredOptions as Record<
+            string,
+            any
+          >,
+          configuredImplies: this.parser.configuredImplies,
+          promptConfigs: allPromptConfigs,
+          providers: allPromptProviders,
+          currentArgs: mergedArgs,
+        });
+
+        // Inject prompted values into accumulated args
+        for (const [key, value] of Object.entries(promptedValues)) {
+          if (value !== undefined) {
+            mergedArgs[key] = value;
+          }
+        }
+      }
+
       try {
         argv = this.parser
           .clone({
@@ -1079,6 +1150,8 @@ export class InternalCLI<
     }
     clone.commandChain = [...this.commandChain];
     clone.requiresCommand = this.requiresCommand;
+    clone.registeredPromptProviders = [...this.registeredPromptProviders];
+    clone.promptConfigs = new Map(this.promptConfigs);
     return clone;
   }
 }

package/src/lib/prompt-types.ts

@@ -0,0 +1,48 @@
+import type { InternalOptionConfig } from '@cli-forge/parser';
+
+/**
+ * Static prompt configuration for an option.
+ * - `true` — always prompt
+ * - `string` — always prompt with this label
+ * - `false` — never prompt
+ */
+export type PromptConfig = boolean | string;
+
+/**
+ * Full prompt configuration, including dynamic resolution.
+ * When a function is provided, it receives accumulated args and returns
+ * a static PromptConfig. Returning null/undefined from the callback
+ * is treated as falsy (don't prompt).
+ */
+export type PromptOptionConfig<TArgs = unknown> =
+  | PromptConfig
+  | ((args: Partial<TArgs>) => PromptConfig | null | undefined);
+
+/**
+ * An option that needs prompting, passed to prompt providers.
+ */
+export interface PromptOption {
+  /** The option name (key) */
+  name: string;
+  /** The full option config from the parser, with resolved prompt value */
+  config: InternalOptionConfig & { prompt?: PromptConfig };
+}
+
+/**
+ * A prompt provider that can fulfill missing option values interactively.
+ */
+export interface PromptProvider {
+  /**
+   * If provided, this provider only handles options where filter returns true.
+   * Providers without filters act as fallbacks.
+   */
+  filter?: (name: string, config: InternalOptionConfig) => boolean;
+  /**
+   * Prompt for a single option. Called per-option if promptBatch is not defined.
+   */
+  prompt?: (option: PromptOption) => Promise<unknown>;
+  /**
+   * Prompt for multiple options at once. Preferred over prompt when available.
+   */
+  promptBatch?: (options: PromptOption[]) => Promise<Record<string, unknown>>;
+}

package/src/lib/public-api.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
 import {
   ArrayOptionConfig,
   BooleanOptionConfig,
@@ -18,6 +18,7 @@ import {
 } from '@cli-forge/parser';
 
 import { InternalCLI } from './internal-cli';
+import type { PromptOptionConfig, PromptProvider } from './prompt-types';
 
 /**
  * Extracts the command name from a Command type.
@@ -87,7 +88,7 @@ export type CommandToChildEntry<T, TParentCLI = undefined> = {
 export interface CLI<
   TArgs extends ParsedArgs = ParsedArgs,
   THandlerReturn = void,
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   TChildren = {},
   TParent = undefined
 > {
@@ -121,7 +122,7 @@ export interface CLI<
     TCommandArgs extends TArgs,
     TChildHandlerReturn,
     TKey extends string,
-    // eslint-disable-next-line @typescript-eslint/ban-types
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
     TChildChildren = {}
   >(
     key: TKey,
@@ -424,6 +425,17 @@ export interface CLI<
     handler: ErrorHandler
   ): CLI<TArgs, THandlerReturn, TChildren, TParent>;
 
+  /**
+   * Registers a prompt provider for interactive option fulfillment.
+   * Multiple providers can be registered. Filtered providers are checked first
+   * (in registration order), then fallback providers (no filter).
+   *
+   * @param provider The prompt provider to register.
+   */
+  withPromptProvider(
+    provider: PromptProvider
+  ): CLI<TArgs, THandlerReturn, TChildren, TParent>;
+
   /**
    * Registers a new option for the CLI command. This option will be accessible
    * within the command handler, as well as any subcommands.
@@ -441,7 +453,7 @@ export interface CLI<
     const TProps extends Record<string, { type: string }>
   >(
     name: TOption,
-    config: ObjectOptionConfig<TCoerce, TProps>
+    config: ObjectOptionConfig<TCoerce, TProps> & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -460,7 +472,7 @@ export interface CLI<
     const TConfig extends StringOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -476,7 +488,7 @@ export interface CLI<
     const TConfig extends NumberOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -492,7 +504,7 @@ export interface CLI<
     const TConfig extends BooleanOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -508,7 +520,7 @@ export interface CLI<
     const TConfig extends ArrayOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -524,7 +536,7 @@ export interface CLI<
     const TOptionConfig extends OptionConfig<any, any, any>
   >(
     name: TOption,
-    config: TOptionConfig
+    config: TOptionConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -551,7 +563,7 @@ export interface CLI<
     const TProps extends Record<string, { type: string }>
   >(
     name: TOption,
-    config: ObjectOptionConfig<TCoerce, TProps>
+    config: ObjectOptionConfig<TCoerce, TProps> & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -570,7 +582,7 @@ export interface CLI<
     const TConfig extends StringOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -586,7 +598,7 @@ export interface CLI<
     const TConfig extends NumberOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -602,7 +614,7 @@ export interface CLI<
     const TConfig extends BooleanOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -618,7 +630,7 @@ export interface CLI<
     const TConfig extends ArrayOptionConfig<any, any>
   >(
     name: TOption,
-    config: TConfig
+    config: TConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -634,7 +646,7 @@ export interface CLI<
     const TOptionConfig extends OptionConfig<any, any, any>
   >(
     name: TOption,
-    config: TOptionConfig
+    config: TOptionConfig & { prompt?: PromptOptionConfig<TArgs> }
   ): CLI<
     TArgs &
       MakeUndefinedPropertiesOptional<{
@@ -928,13 +940,13 @@ export interface CLICommandOptions<
   /**
    * The children commands that exist before the builder runs.
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   TInitialChildren = {},
   TParent = any,
   /**
    * The children commands after the builder runs (includes TInitialChildren plus any added by builder).
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   TChildren = {}
 > {
   /**
@@ -1080,7 +1092,7 @@ export type SDKChildren<TChildren> = {
  * Container commands (no handler) are not callable but still provide access to children.
  */
 export type SDKCommand<TArgs, THandlerReturn, TChildren> =
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   // THandlerReturn extends void | undefined
   // ? SDKChildren<TChildren> // No handler = just children (not callable)
   SDKInvokable<TArgs, THandlerReturn> & SDKChildren<TChildren>;
@@ -1094,7 +1106,7 @@ export type SDKCommand<TArgs, THandlerReturn, TChildren> =
 export function cli<
   TArgs extends ParsedArgs,
   THandlerReturn = void,
-  // eslint-disable-next-line @typescript-eslint/ban-types
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
   TChildren = {},
   TName extends string = string
 >(

package/src/lib/resolve-prompts.spec.ts

@@ -0,0 +1,311 @@
+import { describe, it, expect, vi } from 'vitest';
+import { resolvePrompts } from './resolve-prompts';
+import type { InternalOptionConfig } from '@cli-forge/parser';
+import type { PromptProvider } from './prompt-types';
+
+function makeConfig(
+  overrides: Partial<InternalOptionConfig> & { key: string }
+): InternalOptionConfig {
+  return {
+    type: 'string',
+    ...overrides,
+  } as InternalOptionConfig;
+}
+
+describe('resolvePrompts', () => {
+  it('should return empty object when no options need prompting', async () => {
+    const result = await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map(),
+      providers: [],
+      currentArgs: { name: 'Alice' },
+    });
+    expect(result).toEqual({});
+  });
+
+  it('should prompt for required options missing values', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('prompted-value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name', required: true }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({ name: 'prompted-value' });
+    expect(provider.prompt).toHaveBeenCalledOnce();
+  });
+
+  it('should not prompt for required options that already have values', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('prompted-value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name', required: true }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: { name: 'existing' },
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+
+  it('should call prompt callback with current args', async () => {
+    const promptFn = vi.fn().mockReturnValue('Enter token');
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('token-value'),
+    };
+
+    await resolvePrompts({
+      configuredOptions: {
+        token: makeConfig({ key: 'token' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([['token', promptFn]]),
+      providers: [provider],
+      currentArgs: { someFlag: true },
+    });
+
+    expect(promptFn).toHaveBeenCalledWith({ someFlag: true });
+  });
+
+  it('should not prompt when callback returns null', async () => {
+    const promptFn = vi.fn().mockReturnValue(null);
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        token: makeConfig({ key: 'token' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([['token', promptFn]]),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+
+  it('should prompt for implied options when trigger is set and implied option is missing', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        output: makeConfig({ key: 'output' }),
+        format: makeConfig({ key: 'format' }),
+      },
+      configuredImplies: { output: new Set(['format']) },
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: { output: '/tmp/out' },
+    });
+
+    expect(result).toEqual({ format: 'value' });
+  });
+
+  it('should not prompt for implied options when trigger is not set', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        output: makeConfig({ key: 'output' }),
+        format: makeConfig({ key: 'format' }),
+      },
+      configuredImplies: { output: new Set(['format']) },
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+
+  it('should group options by matched provider for batch calls', async () => {
+    const batchProvider: PromptProvider = {
+      filter: (name) => name.startsWith('db'),
+      promptBatch: vi
+        .fn()
+        .mockResolvedValue({ dbHost: 'localhost', dbPort: 5432 }),
+    };
+    const fallbackProvider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('fallback'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        dbHost: makeConfig({ key: 'dbHost' }),
+        dbPort: makeConfig({ key: 'dbPort' }),
+        name: makeConfig({ key: 'name' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([
+        ['dbHost', true],
+        ['dbPort', true],
+        ['name', true],
+      ]),
+      providers: [batchProvider, fallbackProvider],
+      currentArgs: {},
+    });
+
+    expect(batchProvider.promptBatch).toHaveBeenCalledOnce();
+    expect(fallbackProvider.prompt).toHaveBeenCalledOnce();
+    expect(result).toEqual({
+      dbHost: 'localhost',
+      dbPort: 5432,
+      name: 'fallback',
+    });
+  });
+
+  it('should skip options where prompt is false', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name', required: true }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([['name', false]]),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+
+  it('should throw when options need prompting but no provider matches', async () => {
+    await expect(
+      resolvePrompts({
+        configuredOptions: {
+          name: makeConfig({ key: 'name' }),
+        },
+        configuredImplies: {},
+        promptConfigs: new Map([['name', true]]),
+        providers: [],
+        currentArgs: {},
+      })
+    ).rejects.toThrow(/no prompt provider/i);
+  });
+
+  it('should skip internal options (help, version, unmatched, --)', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        help: makeConfig({ key: 'help', required: true }),
+        version: makeConfig({ key: 'version', required: true }),
+        unmatched: makeConfig({ key: 'unmatched', required: true }),
+        '--': makeConfig({ key: '--', required: true }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+
+  it('should prefer promptBatch over prompt when both are available', async () => {
+    let batchCalled = false;
+    const provider: PromptProvider = {
+      promptBatch: vi.fn().mockImplementation(async (options) => {
+        batchCalled = true;
+        const result: Record<string, unknown> = {};
+        for (const opt of options) {
+          result[opt.name] = 'batch-value';
+        }
+        return result;
+      }),
+      prompt: vi.fn().mockImplementation(async () => {
+        throw new Error('Should not be called when promptBatch exists');
+      }),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        a: makeConfig({ key: 'a' }),
+        b: makeConfig({ key: 'b' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([
+        ['a', true],
+        ['b', true],
+      ]),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(batchCalled).toBe(true);
+    expect(provider.prompt).not.toHaveBeenCalled();
+    expect(result).toEqual({ a: 'batch-value', b: 'batch-value' });
+  });
+
+  it('should prompt with string label when prompt config is a string', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map([['name', 'What is your name?']]),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(provider.prompt).toHaveBeenCalledOnce();
+    const calledOption = (provider.prompt as ReturnType<typeof vi.fn>).mock
+      .calls[0][0];
+    expect(calledOption.name).toBe('name');
+    expect(calledOption.config.prompt).toBe('What is your name?');
+  });
+
+  it('should not prompt for non-required options without explicit prompt config', async () => {
+    const provider: PromptProvider = {
+      prompt: vi.fn().mockResolvedValue('value'),
+    };
+
+    const result = await resolvePrompts({
+      configuredOptions: {
+        name: makeConfig({ key: 'name' }),
+      },
+      configuredImplies: {},
+      promptConfigs: new Map(),
+      providers: [provider],
+      currentArgs: {},
+    });
+
+    expect(result).toEqual({});
+    expect(provider.prompt).not.toHaveBeenCalled();
+  });
+});