@tsed/cli-prompts 7.0.0-beta.11

package/lib/types/interfaces/PromptQuestion.d.ts

@@ -0,0 +1,154 @@
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Enumerates the built-in prompt types supported by the Ts.ED CLI.
+ */
+export type PromptType = "input" | "password" | "confirm" | "list" | "checkbox" | "autocomplete";
+/**
+ * Represents a single choice entry usable by select, checkbox, and autocomplete prompts.
+ */
+export interface PromptChoice<Value = any> {
+    /**
+     * Human friendly label displayed in the prompt list.
+     */
+    name?: string;
+    /**
+     * Raw value returned when the choice is selected.
+     */
+    value?: Value;
+    /**
+     * Optional short label shown beside the main choice name.
+     */
+    short?: string;
+    /**
+     * Marks the choice as disabled (boolean or reason string).
+     */
+    disabled?: boolean | string;
+    /**
+     * For checkbox prompts, marks the choice as checked by default.
+     */
+    checked?: boolean;
+}
+/**
+ * Choice definition accepted by prompts. A plain value will be coerced to a `PromptChoice`.
+ */
+export type PromptChoiceInput<Value = any> = PromptChoice<Value> | Value;
+/**
+ * Transforms user input before it becomes part of the command context.
+ */
+export type PromptTransformer = (input: any, answers: Record<string, any>, flags?: {
+    isFinal?: boolean;
+}) => any;
+/**
+ * Validates the user input, returning `true`, `false`, or an error string.
+ */
+export type PromptValidator = (input: any, answers: Record<string, any>) => MaybePromise<boolean | string>;
+/**
+ * Filters the answer into a different representation before persistence.
+ */
+export type PromptFilter = (input: any, answers: Record<string, any>) => MaybePromise<any>;
+/**
+ * Determines whether a prompt should run.
+ */
+export type PromptWhen = boolean | ((answers: Record<string, any>) => MaybePromise<boolean>);
+/**
+ * Base contract shared by every question type.
+ */
+export interface PromptBaseQuestion<Value = any> {
+    /**
+     * Prompt type to render.
+     */
+    type: PromptType;
+    /**
+     * Unique answer key assigned to the prompt.
+     */
+    name: string;
+    /**
+     * Prompt label. Accepts a string or function (resolved at runtime).
+     */
+    message: string | ((answers: Record<string, any>) => MaybePromise<string>);
+    /**
+     * Allows skipping the prompt based on previous answers.
+     */
+    when?: PromptWhen;
+    /**
+     * Default input value or factory function returning one.
+     */
+    default?: Value | ((answers: Record<string, any>) => MaybePromise<Value>);
+    /**
+     * Mutates the visual input while the user types.
+     */
+    transformer?: PromptTransformer;
+    /**
+     * Validates user input. Return `false`/string to display an error.
+     */
+    validate?: PromptValidator;
+    /**
+     * Mutates the stored answer after validation.
+     */
+    filter?: PromptFilter;
+    /**
+     * Optional max number of rows visible in select/checkbox prompts.
+     */
+    pageSize?: number;
+    /**
+     * Whether select prompts loop when reaching boundaries.
+     */
+    loop?: boolean;
+}
+/**
+ * Plain text prompt.
+ */
+export interface PromptInputQuestion extends PromptBaseQuestion<string> {
+    type: "input";
+}
+/**
+ * Hidden text prompt (e.g., passwords or tokens).
+ */
+export interface PromptPasswordQuestion extends PromptBaseQuestion<string> {
+    type: "password";
+    /**
+     * Character used to mask input (default: •). Set `false` to show raw input.
+     */
+    mask?: string | boolean;
+}
+/**
+ * Boolean confirmation prompt (yes/no).
+ */
+export interface PromptConfirmQuestion extends PromptBaseQuestion<boolean> {
+    type: "confirm";
+}
+/**
+ * Single-select prompt with predefined choices.
+ */
+export interface PromptListQuestion extends PromptBaseQuestion<any> {
+    type: "list";
+    /**
+     * Available choices displayed to the user.
+     */
+    choices: PromptChoiceInput[];
+}
+/**
+ * Multi-select prompt where the result is an array of chosen values.
+ */
+export interface PromptCheckboxQuestion extends PromptBaseQuestion<any[]> {
+    type: "checkbox";
+    /**
+     * Available choices displayed to the user.
+     */
+    choices: PromptChoiceInput[];
+}
+/**
+ * Searchable prompt that fetches choices dynamically.
+ */
+export interface PromptAutocompleteQuestion extends PromptBaseQuestion<any> {
+    type: "autocomplete";
+    /**
+     * Async loader returning the set of choices filtered by the keyword.
+     */
+    source: (answers: Record<string, any>, keyword?: string) => MaybePromise<PromptChoiceInput[]>;
+}
+/**
+ * Union describing every supported Ts.ED CLI question type.
+ */
+export type PromptQuestion = PromptInputQuestion | PromptPasswordQuestion | PromptConfirmQuestion | PromptListQuestion | PromptCheckboxQuestion | PromptAutocompleteQuestion;
+export {};

package/lib/types/utils/applyTransforms.d.ts

@@ -0,0 +1,2 @@
+import type { PromptQuestion } from "../interfaces/PromptQuestion.js";
+export declare function applyTransforms(question: PromptQuestion, answers: Record<string, any>, value: unknown): Promise<unknown>;

package/lib/types/utils/ensureNotCancelled.d.ts

@@ -0,0 +1 @@
+export declare function ensureNotCancelled<T>(value: T | symbol): T;

package/lib/types/utils/getValidationError.d.ts

@@ -0,0 +1,2 @@
+import type { PromptQuestion } from "../interfaces/PromptQuestion.js";
+export declare function getValidationError(question: PromptQuestion, answers: Record<string, unknown>, value: unknown): Promise<string | undefined>;

package/lib/types/utils/normalizeChoices.d.ts

@@ -0,0 +1,8 @@
+import type { PromptChoiceInput } from "../interfaces/PromptQuestion.js";
+export type NormalizedChoice = {
+    label: string;
+    value: any;
+    hint?: string;
+    checked?: boolean;
+};
+export declare function normalizeChoices(inputs?: PromptChoiceInput[]): NormalizedChoice[];

package/lib/types/utils/normalizeQuestion.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedPromptQuestion } from "../interfaces/NormalizedPromptQuestion.js";
+import type { PromptQuestion } from "../interfaces/PromptQuestion.js";
+export declare function normalizeQuestion(question: PromptQuestion, answers: Record<string, unknown>): Promise<NormalizedPromptQuestion>;

package/lib/types/utils/processPrompt.d.ts

@@ -0,0 +1,5 @@
+import type { PromptQuestion } from "../interfaces/PromptQuestion.js";
+export declare const CONTINUE: unique symbol;
+type PromptExecutor = () => Promise<unknown> | unknown;
+export declare function processPrompt(question: PromptQuestion, answers: Record<string, unknown>, cb: PromptExecutor): Promise<unknown>;
+export {};

package/lib/types/utils/resolveListDefault.d.ts

@@ -0,0 +1,3 @@
+import type { PromptAutocompleteQuestion, PromptListQuestion } from "../interfaces/PromptQuestion.js";
+import type { NormalizedChoice } from "./normalizeChoices.js";
+export declare function resolveListDefault(question: Pick<PromptListQuestion | PromptAutocompleteQuestion, "default">, choices: NormalizedChoice[]): any;

package/lib/types/utils/resolveMaybe.d.ts

@@ -0,0 +1 @@
+export declare function resolveMaybe<T>(value: T | ((answers: Record<string, any>) => T | Promise<T>) | undefined, answers: Record<string, any>): Promise<T> | T;

package/lib/types/utils/shouldAsk.d.ts

@@ -0,0 +1,2 @@
+import type { PromptQuestion } from "../interfaces/PromptQuestion.js";
+export declare function shouldAsk(question: PromptQuestion, answers: Record<string, any>): Promise<boolean>;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@tsed/cli-prompts",
+  "description": "Prompt runner and schema shared across Ts.ED CLIs",
+  "version": "7.0.0-beta.11",
+  "type": "module",
+  "main": "./lib/esm/index.js",
+  "source": "./src/index.ts",
+  "module": "./lib/esm/index.js",
+  "typings": "./lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "cli-tsed-source": "./src/index.ts",
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "build": "yarn build:ts",
+    "build:ts": "tsc --build tsconfig.esm.json",
+    "test": "vitest run",
+    "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "@tsed/core": ">=8.21.0",
+    "@tsed/di": ">=8.21.0",
+    "@tsed/hooks": ">=8.21.0",
+    "@tsed/logger": ">=8.0.3"
+  },
+  "devDependencies": {
+    "@tsed/typescript": "7.0.0-beta.11",
+    "typescript": "5.6.2",
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {},
+  "repository": "https://github.com/tsedio/tsed-cli",
+  "bugs": {
+    "url": "https://github.com/tsedio/tsed-cli/issues"
+  },
+  "homepage": "https://github.com/tsedio/tsed-cli/tree/master/packages/cli-prompts",
+  "author": "Romain Lenzotti",
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "beta"
+  }
+}

package/readme.md

@@ -0,0 +1,112 @@
+# @tsed/cli-prompts
+
+<p style="text-align: center" align="center">
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+</p>
+
+[![Build & Release](https://github.com/tsedio/tsed-cli/workflows/Build%20&%20Release/badge.svg?branch=master)](https://github.com/tsedio/tsed-cli/actions?query=workflow%3A%22Build+%26+Release%22)
+[![TypeScript](https://badges.frapsoft.com/typescript/love/typescript.svg?v=100)](https://github.com/ellerbrock/typescript-badges/)
+
+> Ts.ED’s prompt runner, powered by `@clack/prompts`, with a declarative schema shared across every CLI package.
+
+## Goals
+
+`@tsed/cli-prompts` extracts the reusable prompt subsystem that used to live in `@tsed/cli-core`. The package owns:
+
+- The canonical `PromptQuestion` schema used by command providers and template generators.
+- A `PromptRunner` service that evaluates `when` guards, resolves defaults, and dispatches to prompt handlers.
+- A Clack-based implementation of every prompt type Ts.ED commands rely on (`input`, `password`, `confirm`, `list`, `checkbox`, `autocomplete`).
+- Consistent cancellation/Error handling via `PromptCancelledError`.
+
+Shipping this as a standalone package lets other workspaces (and downstream CLIs) reuse the exact same behavior without duplicating abstractions or third-party dependencies.
+
+## Installation
+
+```bash
+npm install @tsed/cli-prompts @tsed/core @tsed/di
+```
+
+> `@tsed/di` is required because the prompt runner is an injectable service.
+
+## Features
+
+- **Clack UX**: Interactively renders all prompts via `@clack/prompts` (selects, multiselects, autocomplete loops, password masking, etc.).
+- **Declarative schema**: Define questions with the standard Ts.ED structure (`name`, `type`, `message`, `choices`, `default`, `when`, `validate`, `filter`, `transformer`).
+- **Async autocomplete**: Built-in support for searchable lists using the `source(answers, keyword)` contract used by `tsed add`, `tsed generate`, and MCP tooling.
+- **Cancellation safety**: `ensureNotCancelled()` converts Ctrl+C / ESC exits into a thrown `PromptCancelledError`, allowing CLI hosts to render a friendly message and abort.
+- **Transformer & validation helpers**: All handlers consistently run `transformer`, `filter`, and `validate` hooks before finalizing the answer.
+
+## Getting started
+
+When you build a CLI that uses `@tsed/cli-core`, the prompt runner is already injected for you. To use it directly, register it inside your DI context:
+
+```typescript
+import {CliPlatformTest} from "@tsed/cli-testing";
+import {PromptRunner, PromptQuestion} from "@tsed/cli-prompts";
+
+await CliPlatformTest.create();
+const runner = await CliPlatformTest.invoke<PromptRunner>(PromptRunner);
+
+const questions: PromptQuestion[] = [
+  {
+    type: "input",
+    name: "packageName",
+    message: "Package name",
+    validate(value) {
+      return value ? true : "Package name is required";
+    }
+  },
+  {
+    type: "autocomplete",
+    name: "feature",
+    message: "Choose a feature",
+    source: async (_answers, keyword = "") => {
+      return ["cli-core", "cli-prompts", "cli-mcp"].filter((entry) => entry.includes(keyword)).map((value) => ({name: value, value}));
+    }
+  }
+];
+
+const answers = await runner.run(questions);
+console.log(answers);
+```
+
+### Supported question types
+
+| Type           | Description                                              |
+| -------------- | -------------------------------------------------------- |
+| `input`        | Free-form text entry with optional transform/validation. |
+| `password`     | Hidden input with customizable mask characters.          |
+| `confirm`      | Boolean yes/no selection.                                |
+| `list`         | Single-select list rendered with Clack’s `select`.       |
+| `checkbox`     | Multi-select list rendered with `multiselect`.           |
+| `autocomplete` | Searchable list that re-queries a `source` function.     |
+
+Every question can declare `when` guards, `default` values (including functions that read previous answers), `pageSize`, and `choices` metadata (`name`, `value`, `short`, `checked`, `disabled`).
+
+### Handling cancellations
+
+Ctrl+C and ESC bubble up as `PromptCancelledError`. Catch it at the application boundary (as `CliCore` does) if you need custom messaging:
+
+```typescript
+import {PromptRunner, PromptCancelledError} from "@tsed/cli-prompts";
+
+try {
+  await runner.run(questionList);
+} catch (er) {
+  if (er instanceof PromptCancelledError) {
+    console.log("Prompt cancelled by the user.");
+    process.exit(0);
+  }
+  throw er;
+}
+```
+
+## Development
+
+This package follows the same conventions as other Ts.ED workspaces:
+
+- `yarn workspace @tsed/cli-prompts build:ts` – compile to `lib/esm` + `lib/types`.
+- `yarn workspace @tsed/cli-prompts test` – run the Vitest suite.
+- `yarn lint` – run the monorepo ESLint config (covers this workspace automatically).
+
+Please read the [contributing guide](https://tsed.dev/CONTRIBUTING.html) before submitting changes.

package/src/PromptRunner.spec.ts

@@ -0,0 +1,64 @@
+import {beforeEach, describe, expect, it, vi} from "vitest";
+
+import {PromptRunner} from "./PromptRunner.js";
+
+const handlerMap = vi.hoisted(() => ({
+  input: vi.fn()
+}));
+
+const handlerModule = vi.hoisted(() => {
+  return new Proxy(handlerMap, {
+    get(target, prop) {
+      return Reflect.get(target, prop);
+    }
+  });
+});
+
+vi.mock("./fn/index.js", () => handlerModule);
+
+describe("PromptRunner", () => {
+  beforeEach(() => {
+    handlerMap.input.mockReset();
+  });
+
+  it("should execute supported prompt types and merge answers", async () => {
+    handlerMap.input.mockResolvedValueOnce("fooValue").mockResolvedValueOnce("barValue");
+
+    const runner = new PromptRunner();
+    const answers = await runner.run(
+      [
+        {type: "input", name: "foo", message: "Foo"},
+        false as any,
+        {
+          type: "input",
+          name: "bar",
+          message: () => "Bar",
+          when: (current) => current.foo === "fooValue"
+        }
+      ],
+      {initial: true}
+    );
+
+    expect(handlerMap.input).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({name: "foo", message: "Foo"}),
+      expect.objectContaining({initial: true})
+    );
+    expect(handlerMap.input).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({name: "bar", message: "Bar"}),
+      expect.objectContaining({foo: "fooValue", initial: true})
+    );
+    expect(answers).toEqual({
+      foo: "fooValue",
+      bar: "barValue"
+    });
+  });
+
+  it("should throw when prompt type is unsupported", async () => {
+    const runner = new PromptRunner();
+    (handlerMap as any).unknown = undefined;
+
+    await expect(runner.run([{type: "unknown" as any, name: "noop", message: "Noop"}])).rejects.toThrow("Unsupported prompt type: unknown");
+  });
+});

package/src/PromptRunner.ts

@@ -0,0 +1,42 @@
+import {injectable} from "@tsed/di";
+
+import * as fn from "./fn/index.js";
+import type {NormalizedPromptQuestion} from "./interfaces/NormalizedPromptQuestion.js";
+import type {PromptQuestion} from "./interfaces/PromptQuestion.js";
+import {normalizeQuestion} from "./utils/normalizeQuestion.js";
+import {shouldAsk} from "./utils/shouldAsk.js";
+
+export class PromptRunner {
+  async run(questions: PromptQuestion[] | undefined, initialAnswers: Record<string, any> = {}) {
+    const queue = ([] as PromptQuestion[]).concat(questions ?? []).filter(Boolean);
+
+    const answers = {...initialAnswers};
+    const collected: Record<string, any> = {};
+
+    for (const question of queue) {
+      if (!(await shouldAsk(question, answers))) {
+        continue;
+      }
+
+      const normalized = await normalizeQuestion(question, answers);
+      const response = await this.prompt(normalized, answers);
+
+      answers[question.name] = response;
+      collected[question.name] = response;
+    }
+
+    return collected;
+  }
+
+  protected async prompt(question: NormalizedPromptQuestion, answers: Record<string, unknown>): Promise<any> {
+    const type = question.type;
+
+    if (!fn[type]) {
+      throw new Error(`Unsupported prompt type: ${type as string}`);
+    }
+
+    return fn[type](question as never, answers);
+  }
+}
+
+injectable(PromptRunner);

package/src/errors/PromptCancelledError.spec.ts

@@ -0,0 +1,13 @@
+import {describe, expect, it} from "vitest";
+
+import {PromptCancelledError} from "./PromptCancelledError.js";
+
+describe("PromptCancelledError", () => {
+  it("should set name and default message", () => {
+    const error = new PromptCancelledError();
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error.name).toBe("PromptCancelledError");
+    expect(error.message).toBe("Prompt cancelled");
+  });
+});

package/src/errors/PromptCancelledError.ts

@@ -0,0 +1,6 @@
+export class PromptCancelledError extends Error {
+  constructor(message = "Prompt cancelled") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+}

package/src/fn/autocomplete.ts

@@ -0,0 +1,77 @@
+import {select, text} from "@clack/prompts";
+
+import type {NormalizedPromptQuestion} from "../interfaces/NormalizedPromptQuestion.js";
+import type {PromptAutocompleteQuestion} from "../interfaces/PromptQuestion.js";
+import {ensureNotCancelled} from "../utils/ensureNotCancelled.js";
+import {normalizeChoices} from "../utils/normalizeChoices.js";
+import {CONTINUE, processPrompt} from "../utils/processPrompt.js";
+import {resolveListDefault} from "../utils/resolveListDefault.js";
+
+const SEARCH_ACTION = "__tsed_cli_search_again__";
+
+export async function autocomplete(question: NormalizedPromptQuestion, answers: Record<string, unknown>) {
+  if (!question.source) {
+    throw new Error(`Question "${question.name}" must provide a source for autocomplete prompts.`);
+  }
+
+  let keyword = "";
+
+  let choices = await resolveAutocompleteChoices(question.source, answers, keyword);
+
+  async function display() {
+    keyword = await promptKeyword(question.message, keyword, true);
+    choices = await resolveAutocompleteChoices(question.source!, answers, keyword);
+  }
+
+  return processPrompt(question, answers, async () => {
+    if (!choices.length) {
+      await display();
+      return CONTINUE;
+    }
+
+    const selection = await select({
+      message: buildAutocompleteMessage(question.message, keyword),
+      options: [
+        ...choices.map((choice) => ({
+          label: choice.label,
+          value: choice.value,
+          hint: choice.hint
+        })),
+        {
+          label: "🔍 Search again",
+          value: SEARCH_ACTION,
+          hint: "Type another keyword"
+        }
+      ],
+      initialValue: resolveListDefault(question, choices),
+      maxItems: question.pageSize
+    });
+
+    if (selection === SEARCH_ACTION) {
+      await display();
+      return CONTINUE;
+    }
+
+    return selection;
+  });
+}
+
+async function resolveAutocompleteChoices(source: PromptAutocompleteQuestion["source"], answers: Record<string, any>, keyword: string) {
+  const items = await source!(answers, keyword);
+
+  return normalizeChoices(items);
+}
+
+async function promptKeyword(message: string, keyword: string, emptyState: boolean) {
+  const label = emptyState ? `${message} (no matches, type to search)` : `${message} (type to refine search)`;
+  const result = await text({
+    message: label,
+    initialValue: keyword
+  });
+
+  return ensureNotCancelled(result).trim();
+}
+
+function buildAutocompleteMessage(message: string, keyword: string) {
+  return keyword ? `${message} (filter: ${keyword})` : message;
+}

package/src/fn/checkbox.ts

@@ -0,0 +1,40 @@
+import {multiselect} from "@clack/prompts";
+import {isArray} from "@tsed/core/utils/isArray";
+
+import type {NormalizedPromptQuestion} from "../interfaces/NormalizedPromptQuestion.js";
+import type {NormalizedChoice} from "../utils/normalizeChoices.js";
+import {processPrompt} from "../utils/processPrompt.js";
+
+export async function checkbox(question: NormalizedPromptQuestion, answers: Record<string, unknown>) {
+  if (!question.choices?.length) {
+    throw new Error(`Question "${question.name}" does not provide any choices`);
+  }
+
+  const initialValues = resolveCheckboxDefaults(question, question.choices);
+
+  return processPrompt(question, answers, () =>
+    multiselect({
+      message: question.message,
+      options: question.choices!.map((choice) => ({
+        label: choice.label,
+        value: choice.value,
+        hint: choice.hint
+      })),
+      initialValues
+    })
+  );
+}
+
+function resolveCheckboxDefaults(question: NormalizedPromptQuestion, choices: NormalizedChoice[]) {
+  if (isArray(question.default)) {
+    return question.default;
+  }
+
+  if (question.default !== undefined) {
+    return [question.default];
+  }
+
+  const checkedValues = choices.filter((choice) => choice.checked).map((choice) => choice.value);
+
+  return checkedValues.length ? checkedValues : [];
+}

package/src/fn/confirm.ts

@@ -0,0 +1,16 @@
+import {confirm as c} from "@clack/prompts";
+import {isBoolean} from "@tsed/core/utils/isBoolean.js";
+
+import type {NormalizedPromptQuestion} from "../interfaces/NormalizedPromptQuestion.js";
+import {processPrompt} from "../utils/processPrompt.js";
+
+export async function confirm(question: NormalizedPromptQuestion, answers: Record<string, unknown>) {
+  const initialValue = isBoolean(question.default) ? question.default : undefined;
+
+  return processPrompt(question, answers, () =>
+    c({
+      message: question.message,
+      initialValue
+    })
+  );
+}

package/src/fn/index.ts

@@ -0,0 +1,6 @@
+export {autocomplete} from "./autocomplete.js";
+export {checkbox} from "./checkbox.js";
+export {confirm} from "./confirm.js";
+export {input} from "./input.js";
+export {list} from "./list.js";
+export {password} from "./password.js";

package/src/fn/input.ts

@@ -0,0 +1,13 @@
+import {text} from "@clack/prompts";
+
+import type {NormalizedPromptQuestion} from "../interfaces/NormalizedPromptQuestion.js";
+import {processPrompt} from "../utils/processPrompt.js";
+
+export async function input(question: NormalizedPromptQuestion, answers: Record<string, unknown>) {
+  return processPrompt(question, answers, () =>
+    text({
+      message: question.message,
+      initialValue: String(question.default ?? "")
+    })
+  );
+}

package/src/fn/list.ts

@@ -0,0 +1,24 @@
+import {select} from "@clack/prompts";
+
+import type {NormalizedPromptQuestion} from "../interfaces/NormalizedPromptQuestion.js";
+import {processPrompt} from "../utils/processPrompt.js";
+import {resolveListDefault} from "../utils/resolveListDefault.js";
+
+export async function list(question: NormalizedPromptQuestion, answers: Record<string, unknown>) {
+  if (!question.choices?.length) {
+    throw new Error(`Question "${question.name}" does not provide any choices`);
+  }
+
+  return processPrompt(question, answers, () =>
+    select({
+      message: question.message,
+      options: question.choices!.map((choice) => ({
+        label: choice.label,
+        value: choice.value,
+        hint: choice.hint
+      })),
+      initialValue: resolveListDefault(question, question.choices!),
+      maxItems: question.pageSize
+    })
+  );
+}