@sous-io/sous 0.2.37 → 1.0.2

package/src/templating/tags/getFiles.ts

@@ -1,89 +0,0 @@
-import { Hash, type Liquid } from "liquidjs";
-import type { Context } from "liquidjs/dist/context/context.js";
-import type { TagToken } from "liquidjs/dist/tokens/tag-token.js";
-import { globFiles, parseGlobList, type GlobFile } from "../lib/glob-files.js";
-import { splitPositionalName } from "../lib/tag-args.js";
-import { importNamedExport } from "../lib/import-export.js";
-
-/**
- * Registers the `{% getFiles <varName> root="..." include="..." exclude="..." import="..." %}`
- * tag. It globs files under `root` and assigns the resulting array to `<varName>`
- * in the template scope. It renders no output — use a `{% for %}` loop to present
- * the results.
- *
- * Each result has `{ path, dir, relPath, name }`. When the optional `import`
- * attribute names an export (e.g. `import="meta"`), each file is dynamically
- * imported and that export is attached under the same key (e.g. `file.meta`);
- * files that fail to import or lack the export are omitted from the results.
- *
- * Attribute values may be quoted strings or scope variables (e.g. `root=tasksDir`).
- * `include`/`exclude` are comma-separated glob patterns matched relative to `root`.
- */
-export function registerGetFilesTag(engine: Liquid): void {
-  engine.registerTag("getFiles", {
-    parse(token: TagToken) {
-      const { name, rest } = splitPositionalName(token.args);
-      this.varName = name;
-      this.hash = new Hash(rest, true);
-    },
-
-    *render(ctx: Context): Generator<unknown, string, Record<string, unknown>> {
-      const hash = yield this.hash.render(ctx);
-      const varName: string | null = this.varName;
-
-      const files = (yield resolveFiles(hash)) as unknown;
-
-      if (varName) {
-        (ctx.bottom() as Record<string, unknown>)[varName] = files;
-      }
-      return "";
-    },
-  });
-}
-
-/** A file record optionally carrying a dynamically-imported export. */
-type ResolvedFile = GlobFile & Record<string, unknown>;
-
-/**
- * Resolve the glob attributes from a rendered hash into file records, applying
- * the optional `import` export attachment.
- *
- * @param hash - The rendered tag attributes (`root`, `include`, `exclude`, `import`).
- * @returns The matched files, each optionally carrying the imported export.
- */
-async function resolveFiles(hash: Record<string, unknown>): Promise<ResolvedFile[]> {
-  const root = hash.root != null ? String(hash.root) : "";
-  if (!root) {
-    throw new Error('getFiles: a "root" attribute is required');
-  }
-
-  const files = await globFiles({
-    root,
-    include: parseGlobList(hash.include != null ? String(hash.include) : undefined),
-    exclude: parseGlobList(hash.exclude != null ? String(hash.exclude) : undefined),
-  });
-
-  const importName = hash.import != null ? String(hash.import).trim() : "";
-  if (!importName) return files as ResolvedFile[];
-
-  return attachImports(files, importName);
-}
-
-/**
- * For each file, dynamically import `importName` and attach it under that key.
- * Files whose import fails or lacks the export are dropped from the result.
- *
- * @param files - The globbed file records.
- * @param importName - The export to read from each file.
- * @returns Files that successfully yielded the export, with it attached.
- */
-async function attachImports(files: GlobFile[], importName: string): Promise<ResolvedFile[]> {
-  const enriched = await Promise.all(
-    files.map(async (file) => {
-      const value = await importNamedExport(file.path, importName);
-      if (value === undefined) return null;
-      return { ...file, [importName]: value };
-    })
-  );
-  return enriched.filter((f): f is ResolvedFile => f !== null);
-}

package/src/templating/tags/index.ts

@@ -1,14 +0,0 @@
-import type { Liquid } from "liquidjs";
-import { registerShowVarsTag } from "./showVars.js";
-import { registerExportScalarVarsJsTag } from "./exportScalarVarsJs.js";
-import { registerGetFilesTag } from "./getFiles.js";
-import { registerListFilesTag } from "./listFiles.js";
-
-const tagRegistrars: Array<(engine: Liquid) => void> = [
-  registerShowVarsTag,
-  registerExportScalarVarsJsTag,
-  registerGetFilesTag,
-  registerListFilesTag,
-];
-
-export default tagRegistrars;

package/src/templating/tags/listFiles.ts

@@ -1,54 +0,0 @@
-import { Hash, type Liquid } from "liquidjs";
-import type { Context } from "liquidjs/dist/context/context.js";
-import type { TagToken } from "liquidjs/dist/tokens/tag-token.js";
-import { globFiles, parseGlobList, type GlobFile } from "../lib/glob-files.js";
-
-/**
- * Registers the `{% listFiles root="..." include="..." exclude="..." %}` tag.
- * It globs files under `root` and renders them directly as a simple markdown
- * bullet list of file names — the convenience counterpart to `getFiles`.
- *
- * For custom presentation (or to read file metadata), use `getFiles` with a
- * `{% for %}` loop instead. `listFiles` is intentionally glob-only and emits a
- * fixed format.
- *
- * Attribute values may be quoted strings or scope variables. `include`/`exclude`
- * are comma-separated glob patterns matched relative to `root`. An optional
- * `relative="true"` renders relative paths instead of bare file names.
- */
-export function registerListFilesTag(engine: Liquid): void {
-  engine.registerTag("listFiles", {
-    parse(token: TagToken) {
-      this.hash = new Hash(token.args, true);
-    },
-
-    *render(ctx: Context): Generator<unknown, string, Record<string, unknown>> {
-      const hash = yield this.hash.render(ctx);
-      const files = (yield resolveFiles(hash)) as unknown as GlobFile[];
-      const useRelative = String(hash.relative ?? "") === "true";
-
-      if (files.length === 0) return "";
-      return files
-        .map((f) => `- ${useRelative ? f.relPath : f.name}`)
-        .join("\n");
-    },
-  });
-}
-
-/**
- * Resolve the glob attributes from a rendered hash into file records.
- *
- * @param hash - The rendered tag attributes (`root`, `include`, `exclude`).
- * @returns The matched files.
- */
-async function resolveFiles(hash: Record<string, unknown>): Promise<GlobFile[]> {
-  const root = hash.root != null ? String(hash.root) : "";
-  if (!root) {
-    throw new Error('listFiles: a "root" attribute is required');
-  }
-  return globFiles({
-    root,
-    include: parseGlobList(hash.include != null ? String(hash.include) : undefined),
-    exclude: parseGlobList(hash.exclude != null ? String(hash.exclude) : undefined),
-  });
-}

package/src/templating/tags/showVars.ts

@@ -1,28 +0,0 @@
-import type { Liquid } from "liquidjs";
-import type { Context } from "liquidjs/dist/context/context.js";
-import { sortObjectKeys } from "../../utils/formatting.js";
-import { HIDDEN_VALUE, isSecretEntry } from "../lib/secret-scope.js";
-
-/**
- * Dumps all variables currently in scope as a fenced JSON block. A secret (one a
- * recipe declared, or one that very probably is) prints as `(hidden)`, so the
- * dump never carries it into compiled output.
- */
-export function registerShowVarsTag(engine: Liquid): void {
-  engine.registerTag("showVars", {
-    render(ctx: Context) {
-      const seen = new WeakSet();
-      const scope = sortObjectKeys(ctx.getAll() as Record<string, unknown>);
-      const json = JSON.stringify(scope, (key, value) => {
-        if (typeof value === "object" && value !== null) {
-          if (seen.has(value)) return "[Circular]";
-          seen.add(value);
-        }
-        if (key !== "" && isSecretEntry(engine, key, value)) return HIDDEN_VALUE;
-        return value;
-      }, 2);
-
-      return "# Sous Debug: Variable Dump\n```json\n" + json + "\n```";
-    },
-  });
-}

package/src/utils/choice-prompt.ts

@@ -1,143 +0,0 @@
-/**
- * The pick-one question sous asks for a recipe variable with a fixed set of
- * allowed values.
- *
- * It behaves like the stock `select` prompt (arrow keys to move, Enter to
- * choose, the default preselected) with the one addition every sous question
- * shares: Tab resolves the question with `{ kind: "advanced" }` instead of
- * moving the cursor, so the caller can show the advanced view and then ask the
- * same question again. Built on the public `@inquirer/core` hooks only.
- */
-
-import {
-  createPrompt,
-  isDownKey,
-  isEnterKey,
-  isTabKey,
-  isUpKey,
-  useKeypress,
-  usePrefix,
-  useState,
-  type Status,
-} from "@inquirer/core";
-import { promptBottom } from "./formatting.js";
-
-/** One value the question offers, and how it is written on screen. */
-export interface PromptChoice {
-  /** The line shown in the list. */
-  name: string;
-  /** The value handed back when the line is chosen. */
-  value: string;
-}
-
-/** What the pick-one question needs in order to ask itself. */
-export interface ChoicePromptConfig {
-  /** The one-line question. */
-  message: string;
-  /** The values on offer, in the order they are listed. */
-  choices: PromptChoice[];
-  /** The value that starts out highlighted, so Enter alone accepts it. */
-  default?: string;
-  /** A line under the list: the key legend, in the stock prompts' style. */
-  hint?: string;
-}
-
-/** How the question ended: with a choice, or with a request for the advanced view. */
-export type ChoicePromptResult = { kind: "value"; value: string } | { kind: "advanced" };
-
-/** Everything the renderer draws, so it can be tested without a terminal. */
-export interface ChoicePromptView {
-  /** The prompt prefix (the question mark, or the check mark once answered). */
-  prefix: string;
-  /** The one-line question. */
-  message: string;
-  /** The values on offer, in the order they are listed. */
-  choices: PromptChoice[];
-  /** Which choice is highlighted, counting from zero. */
-  active: number;
-  /** A line under the list: the key legend, in the stock prompts' style. */
-  hint?: string;
-  /** Whether the question has been answered, which replaces the list with the answer. */
-  answered?: boolean;
-}
-
-/** The pointer drawn beside the highlighted choice. */
-const POINTER = ">";
-
-/**
- * Draws the question: prefix and message on the first line, then one line per
- * choice with a pointer beside the highlighted one, and the hint underneath.
- * Once the question is answered the list gives way to the chosen value, so the
- * scrollback keeps one tidy line per question.
- *
- * @param view - The prompt's state.
- * @returns The question line and the block under it.
- */
-export function renderChoicePrompt(view: ChoicePromptView): [string, string] {
-  const chosen = view.choices[view.active];
-
-  if (view.answered === true) {
-    return [`${view.prefix} ${view.message}: ${chosen?.name ?? ""}`.trimEnd(), ""];
-  }
-
-  const lines = view.choices.map(
-    (choice, index) => `${index === view.active ? POINTER : " "} ${choice.name}`
-  );
-  if (view.hint !== undefined && view.hint !== "") lines.push(view.hint);
-
-  return [`${view.prefix} ${view.message}`.trimEnd(), promptBottom(lines.join("\n"))];
-}
-
-/** Asks one pick-one question, with Tab bound to the advanced view. */
-export const choicePrompt = createPrompt<ChoicePromptResult, ChoicePromptConfig>(
-  (config, done) => {
-    const [status, setStatus] = useState<Status>("idle");
-    const [answered, setAnswered] = useState(false);
-    const [active, setActive] = useState(
-      Math.max(
-        0,
-        config.choices.findIndex((choice) => choice.value === config.default)
-      )
-    );
-    const prefix = usePrefix({ status });
-
-    useKeypress((key, rl) => {
-      if (status !== "idle") return;
-      // Readline echoes whatever was pressed into its buffer; take it back out.
-      rl.clearLine(0);
-
-      if (isTabKey(key)) {
-        setStatus("done");
-        done({ kind: "advanced" });
-        return;
-      }
-
-      if (isEnterKey(key)) {
-        const chosen = config.choices[active];
-        if (chosen === undefined) return;
-        setAnswered(true);
-        setStatus("done");
-        done({ kind: "value", value: chosen.value });
-        return;
-      }
-
-      if (isUpKey(key)) {
-        setActive((active - 1 + config.choices.length) % config.choices.length);
-        return;
-      }
-
-      if (isDownKey(key)) {
-        setActive((active + 1) % config.choices.length);
-      }
-    });
-
-    return renderChoicePrompt({
-      prefix,
-      message: config.message,
-      choices: config.choices,
-      active,
-      ...(config.hint === undefined ? {} : { hint: config.hint }),
-      ...(answered ? { answered: true } : {}),
-    });
-  }
-);

package/src/utils/command-errors.ts

@@ -1,186 +0,0 @@
-/**
- * One way for every sous command to report a failure.
- *
- * A person who forgets an argument, misspells a flag, or runs sous where there
- * is no config has made an ordinary mistake, and what they need back is the
- * sentence describing it (plus, when the mistake is a usage one, the command's
- * own help). A stack trace pointing into oclif's parser tells them nothing, so
- * no expected failure prints one. A trace is still one environment variable
- * away: set `SOUS_DEBUG` and every reported error prints its stack to stderr.
- *
- * The same reporting is used by every command. `BaseCommand.catch` calls it for
- * the commands that discover a config; the repository authoring commands
- * (`repo init`, `repo release`, `repo submit`) extend oclif's `Command`
- * directly and call it from their own `catch`, so all of sous fails the same
- * way.
- */
-
-import { Errors, type Command } from "@oclif/core";
-import { isConfigError } from "../lib/errors.js";
-import { wantsHelp } from "../lib/interactive.js";
-import { displayErrorBlock, log } from "./formatting.js";
-import { printCommandHelpToStderr } from "./command-help.js";
-
-/** The environment variable that turns stack traces back on. */
-export const DEBUG_ENV_VAR = "SOUS_DEBUG";
-
-/**
- * Values of `SOUS_DEBUG` that mean "not set". Everything else counts as set,
- * because people spell it `1`, `true` and `yes` in roughly equal measure. The
- * same list gates the `CI` variable in `lib/interactive.ts`.
- */
-const FALSY_DEBUG_VALUES = new Set(["", "0", "false", "no", "off"]);
-
-/** The line oclif appends to a parse error, replaced by the help screen itself. */
-const OCLIF_HELP_HINT = "See more help with --help";
-
-/** The sentence an unexpected failure ends with, since sous cannot explain it. */
-const UNEXPECTED_REMEDY = `Sous did not expect this error; set '${DEBUG_ENV_VAR}=1' and run the command again for the full stack trace.`;
-
-/** Where the report is written, and what it reads to decide about traces. */
-export type ErrorReportOptions = {
-  /**
-   * Line sink for the error text. Defaults to stdout via `log`; commands whose
-   * stdout must stay machine-readable pass a stderr writer.
-   */
-  write?: (line: string) => void;
-  /** The environment, read for `SOUS_DEBUG`. Defaults to `process.env`. */
-  env?: NodeJS.ProcessEnv;
-};
-
-/**
- * True when this run was asked for stack traces, either by `SOUS_DEBUG` or by
- * oclif's own debug setting (which `--debug`-style bootstrapping turns on).
- *
- * @param env - The environment to read. Defaults to the real one.
- */
-export function stackTracesRequested(env: NodeJS.ProcessEnv = process.env): boolean {
-  const oclifDebug = (globalThis as { oclif?: { debug?: boolean } }).oclif?.debug;
-  if (oclifDebug === true) return true;
-
-  const raw = env[DEBUG_ENV_VAR];
-  if (raw === undefined) return false;
-  return !FALSY_DEBUG_VALUES.has(raw.trim().toLowerCase());
-}
-
-/**
- * True when the "error" is only a request to end the process, which every
- * `this.exit(code)` raises. It carries no message and must reach oclif
- * untouched, or a clean exit would be reported as a failure.
- *
- * @param error - The thrown value.
- */
-export function isExitSignal(error: unknown): boolean {
-  if (error instanceof Errors.ExitError) return true;
-  return typeof error === "object" && error !== null && (error as { code?: string }).code === "EEXIT";
-}
-
-/**
- * True when the caller got the command line wrong (a missing argument, an
- * unknown flag, a value outside a flag's options) or asked a question sous
- * could not ask. Both are answered by showing the command's own help, so both
- * are treated the same way.
- *
- * oclif's parse errors all carry a `parse` property; nothing else oclif throws
- * does, which is what separates a usage mistake from a reported failure.
- *
- * @param error - The thrown value.
- */
-export function isUsageError(error: unknown): boolean {
-  if (wantsHelp(error)) return true;
-  return error instanceof Errors.CLIError && "parse" in error;
-}
-
-/**
- * Reports one command failure in sous's own voice: the message, the command's
- * help underneath it when the message alone is not enough, and a stack trace
- * only when one was asked for.
- *
- * @param command - The command that failed, whose help may be drawn.
- * @param error - The error it failed with.
- * @param options - Where to write, and the environment to read.
- * @returns The exit code the run should end with, or undefined when this error
- *   is not sous's to report and must fall through to oclif's own handling.
- */
-export async function reportCommandError(
-  command: Command,
-  error: Error & { exitCode?: number; oclif?: { exit?: number | false } },
-  options: ErrorReportOptions = {}
-): Promise<number | undefined> {
-  // A clean exit, and a command rendering its own JSON error, both belong to
-  // oclif; neither is a failure for sous to describe.
-  if (isExitSignal(error)) return undefined;
-  if (jsonRequested(command)) return undefined;
-
-  const write = options.write ?? log;
-  const showHelp = isUsageError(error);
-  const expected = showHelp || isConfigError(error) || error instanceof Errors.CLIError;
-
-  const body = [messageOf(error, showHelp)];
-  if (!expected) body.push("", UNEXPECTED_REMEDY);
-
-  displayErrorBlock(body.join("\n"), write);
-
-  if (stackTracesRequested(options.env ?? process.env)) writeStackToStderr(error);
-  if (showHelp) await printCommandHelpToStderr(command);
-
-  return exitCodeOf(error);
-}
-
-/**
- * The message to print, with oclif's "See more help with --help" line removed
- * when the help itself is about to be printed underneath it.
- *
- * @param error - The error being reported.
- * @param showHelp - Whether the command's help follows the message.
- */
-function messageOf(error: Error, showHelp: boolean): string {
-  const message = error.message?.trim() === "" ? String(error) : error.message;
-  if (!showHelp) return message;
-  return message
-    .split("\n")
-    .filter((line) => line.trim() !== OCLIF_HELP_HINT)
-    .join("\n")
-    .trimEnd();
-}
-
-/**
- * Writes an error's stack to stderr, verbatim and uncolored. It is diagnostic
- * output for whoever set `SOUS_DEBUG`, never part of what the command prints.
- *
- * @param error - The error whose stack to write.
- */
-function writeStackToStderr(error: Error): void {
-  const stack = error.stack ?? "";
-  if (stack.trim() === "") return;
-  process.stderr.write(`${stack}\n`);
-}
-
-/**
- * The exit code a failure ends with: the one oclif assigned when it assigned
- * one (a parse error exits 2), and 1 for everything else.
- *
- * @param error - The error being reported.
- */
-function exitCodeOf(error: Error & { exitCode?: number; oclif?: { exit?: number | false } }): number {
-  const fromOclif = error.oclif?.exit;
-  if (typeof fromOclif === "number" && Number.isInteger(fromOclif)) return fromOclif;
-  if (typeof error.exitCode === "number" && Number.isInteger(error.exitCode)) return error.exitCode;
-  return 1;
-}
-
-/**
- * True when the command is rendering machine-readable JSON, in which case oclif
- * owns the error output and sous must not print a human error over it.
- *
- * @param command - The command that failed.
- */
-function jsonRequested(command: Command): boolean {
-  const enabled = (command as { jsonEnabled?: () => boolean }).jsonEnabled;
-  if (typeof enabled !== "function") return false;
-  try {
-    return enabled.call(command) === true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/command-help.ts

@@ -1,45 +0,0 @@
-/**
- * Printing a command's own help underneath an error.
- *
- * A run that failed because a question could not be asked should show the
- * caller every flag that would have answered it, without sending them off to
- * `sous help <command>`. The same goes for a run that failed because the
- * command line itself was wrong. `utils/command-errors.ts` decides when a
- * failure earns a help screen; this module draws it, so every command in sous
- * draws exactly the same one.
- */
-
-import { loadHelpClass, type Command } from "@oclif/core";
-
-/**
- * Prints one command's help, always to stderr.
- *
- * An error is not output, and a command whose stdout is being piped must not
- * have a help screen spliced into its stream. oclif's help writes to stdout, so
- * stdout is pointed at stderr for the duration and put back afterwards. The help
- * class is the one oclif itself uses for `--help`, `-h` and the `help` command,
- * so all four routes draw the same screen.
- *
- * Drawing the help is a courtesy: a failure to draw it must never replace the
- * error that is actually being reported, so everything here is swallowed.
- *
- * @param command - The command whose help to draw.
- */
-export async function printCommandHelpToStderr(command: Command): Promise<void> {
-  const writeToStdout = process.stdout.write.bind(process.stdout);
-  process.stdout.write = ((chunk: string | Uint8Array, ...rest: unknown[]) =>
-    (process.stderr.write as (...args: unknown[]) => boolean)(
-      chunk,
-      ...rest
-    )) as typeof process.stdout.write;
-
-  try {
-    const HelpClass = await loadHelpClass(command.config);
-    const help = new HelpClass(command.config);
-    await help.showHelp([command.id ?? ""]);
-  } catch {
-    // The help screen is a courtesy; never let it replace the real error.
-  } finally {
-    process.stdout.write = writeToStdout;
-  }
-}

package/src/utils/confirm-prompt.ts

@@ -1,110 +0,0 @@
-/**
- * The yes-or-no question sous asks for a recipe variable that holds a boolean.
- *
- * It behaves like the stock `confirm` prompt (the y and n keys answer it, Enter
- * alone accepts the default, which is the capitalised letter) with the one
- * addition every sous question shares: Tab resolves the question with
- * `{ kind: "advanced" }`, so the caller can show the advanced view and then ask
- * the same question again. Built on the public `@inquirer/core` hooks only.
- */
-
-import {
-  createPrompt,
-  isEnterKey,
-  isTabKey,
-  useKeypress,
-  usePrefix,
-  useState,
-  type Status,
-} from "@inquirer/core";
-import { promptBottom } from "./formatting.js";
-
-/** What the yes-or-no question needs in order to ask itself. */
-export interface ConfirmPromptConfig {
-  /** The one-line question. */
-  message: string;
-  /** The answer Enter alone accepts. Defaults to yes. */
-  default?: boolean;
-  /** A line under the question: the key legend, in the stock prompts' style. */
-  hint?: string;
-}
-
-/** How the question ended: with an answer, or with a request for the advanced view. */
-export type ConfirmPromptResult = { kind: "value"; value: boolean } | { kind: "advanced" };
-
-/** Everything the renderer draws, so it can be tested without a terminal. */
-export interface ConfirmPromptView {
-  /** The prompt prefix (the question mark, or the check mark once answered). */
-  prefix: string;
-  /** The one-line question. */
-  message: string;
-  /** The answer Enter alone accepts. Defaults to yes. */
-  default?: boolean;
-  /** The answer given, once there is one. */
-  answer?: boolean;
-  /** A line under the question: the key legend, in the stock prompts' style. */
-  hint?: string;
-}
-
-/**
- * Draws the question: prefix, message and the two keys with the default
- * capitalised, replaced by the answer itself once one is given, plus the hint
- * on the line underneath. A yes or no is never a secret, so nothing here is
- * ever masked.
- *
- * @param view - The prompt's state.
- * @returns The question line and the line under it.
- */
-export function renderConfirmPrompt(view: ConfirmPromptView): [string, string] {
-  const fallback = view.default ?? true;
-  const keys = fallback ? "(Y/n)" : "(y/N)";
-  const tail = view.answer === undefined ? keys : view.answer ? "yes" : "no";
-  const line = `${view.prefix} ${view.message} ${tail}`.trimEnd();
-
-  if (view.answer !== undefined) return [line, ""];
-  return [line, promptBottom(view.hint ?? "")];
-}
-
-/** Asks one yes-or-no question, with Tab bound to the advanced view. */
-export const confirmPrompt = createPrompt<ConfirmPromptResult, ConfirmPromptConfig>(
-  (config, done) => {
-    const [status, setStatus] = useState<Status>("idle");
-    const [answer, setAnswer] = useState<boolean | undefined>(undefined);
-    const prefix = usePrefix({ status });
-
-    /** Settles the question with one answer, and draws it in place of the keys. */
-    const settle = (value: boolean): void => {
-      setAnswer(value);
-      setStatus("done");
-      done({ kind: "value", value });
-    };
-
-    useKeypress((key, rl) => {
-      if (status !== "idle") return;
-      // Readline echoes whatever was pressed into its buffer; take it back out.
-      rl.clearLine(0);
-
-      if (isTabKey(key)) {
-        setStatus("done");
-        done({ kind: "advanced" });
-        return;
-      }
-
-      if (isEnterKey(key)) {
-        settle(config.default ?? true);
-        return;
-      }
-
-      if (key.name === "y") settle(true);
-      else if (key.name === "n") settle(false);
-    });
-
-    return renderConfirmPrompt({
-      prefix,
-      message: config.message,
-      ...(config.default === undefined ? {} : { default: config.default }),
-      ...(answer === undefined ? {} : { answer }),
-      ...(config.hint === undefined ? {} : { hint: config.hint }),
-    });
-  }
-);