@shaferllc/keel 0.68.0 → 0.77.0

package/dist/core/cli/index.js

@@ -0,0 +1,427 @@
+/**
+ * The Keel console. `keel <command>`.
+ *
+ * Commands:
+ *   keel serve                 start the HTTP server
+ *   keel make:controller Foo   generate app/Controllers/FooController.ts
+ *   keel make:provider Foo      generate app/Providers/FooServiceProvider.ts
+ *   keel make:middleware Foo    generate app/Http/Middleware/foo.ts
+ *   keel make:factory User      generate database/factories/UserFactory.ts
+ *   keel make:seeder Database   generate database/seeders/DatabaseSeeder.ts
+ *   keel make:job SendWelcome   generate app/Jobs/SendWelcomeJob.ts
+ *   keel make:notification Paid generate app/Notifications/PaidNotification.ts
+ *   keel make:transformer User  generate app/Transformers/UserTransformer.ts
+ *   keel routes                 list registered routes
+ *   keel mcp                    start the MCP server (docs + API for AI agents)
+ */
+import { mkdir, writeFile, access, readdir, stat, copyFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ConsoleKernel, defineCommand, arg, flag } from "../console.js";
+import { HttpKernel } from "../http/kernel.js";
+import { Router } from "../http/router.js";
+import { getConnection } from "../database.js";
+import { Migrator } from "../migrations.js";
+import { MigrationRegistry, CommandRegistry, PublishRegistry } from "../package.js";
+import { controllerStub, resourceControllerStub, providerStub, middlewareStub, factoryStub, seederStub, jobStub, notificationStub, transformerStub, packageProviderStub, pageStub, commandStub, } from "./stubs.js";
+const basePath = process.cwd();
+async function generate(relPath, contents, label, ui) {
+    const full = join(basePath, relPath);
+    try {
+        await access(full);
+        // Never clobber a file someone has written code in.
+        ui.error(`${label} already exists: ${relPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    catch {
+        // does not exist — proceed
+    }
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, contents);
+    ui.action("create", relPath);
+}
+/** Normalize "foo" / "FooController" into a canonical suffixed class name. */
+function className(name, suffix) {
+    const base = name.replace(new RegExp(`${suffix}$`, "i"), "");
+    const pascal = base.charAt(0).toUpperCase() + base.slice(1);
+    return `${pascal}${suffix}`;
+}
+/** Load every migration under database/migrations/, in filename order. */
+async function discoverMigrations() {
+    const dir = join(basePath, "database/migrations");
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return []; // no migrations directory — fine
+    }
+    const out = [];
+    for (const file of files.sort()) {
+        if (!/\.(ts|js|mjs)$/.test(file))
+            continue;
+        const mod = await import(pathToFileURL(join(dir, file)).href);
+        const def = (mod.default ?? mod.migration ?? mod);
+        if (Array.isArray(def))
+            out.push(...def);
+        else if (def && typeof def.up === "function")
+            out.push(def);
+    }
+    return out;
+}
+/** Every migration to run: the app's discovered ones, then package-contributed. */
+async function collectMigrations(app) {
+    return [...(await discoverMigrations()), ...app.make(MigrationRegistry).all()];
+}
+/** A `Migrator` on the default connection, or a friendly error if none is set. */
+function migratorFor() {
+    const { connection, dialect } = getConnection(); // throws if no connection registered
+    return new Migrator(connection, dialect);
+}
+/** Copy a published file/dir into the app, skipping existing files unless forced. */
+async function publishPath(from, toRel, force, ui) {
+    const dest = join(basePath, toRel);
+    const s = await stat(from).catch(() => null);
+    if (!s) {
+        ui.error(`Source not found: ${from}`);
+        return;
+    }
+    if (s.isDirectory()) {
+        for (const item of await readdir(from)) {
+            await publishPath(join(from, item), join(toRel, item), force, ui);
+        }
+        return;
+    }
+    let exists = false;
+    try {
+        await access(dest);
+        exists = true;
+    }
+    catch {
+        // destination is free
+    }
+    if (exists && !force) {
+        ui.action("skip", `${toRel} (exists; pass --force to overwrite)`, "skipped");
+        return;
+    }
+    await mkdir(dirname(dest), { recursive: true });
+    await copyFile(from, dest);
+    ui.action("publish", toRel);
+}
+export async function run(argv, options) {
+    // Boot the app once so commands share it, and so package providers get a
+    // chance to contribute migrations, commands, and publishables. Scaffolding
+    // commands (`make:*`) don't need it, so a boot failure isn't fatal — it's
+    // surfaced only when a command that needs the app actually runs.
+    let app = null;
+    let bootError;
+    try {
+        app = await options.createApplication();
+    }
+    catch (err) {
+        bootError = err;
+    }
+    const requireApp = () => {
+        if (!app) {
+            console.error("✗ Could not boot the application:");
+            console.error(bootError);
+            process.exit(1);
+        }
+        return app;
+    };
+    /**
+     * Commands your app defines with `defineCommand()`, discovered from
+     * `app/Commands`. They register alongside the built-ins — same kernel, same
+     * typed args and flags — and an app command of the same name wins, so you can
+     * override one.
+     */
+    async function appCommands() {
+        const dir = join(basePath, "app/Commands");
+        const found = [];
+        const files = await readdir(dir).catch(() => null);
+        if (!files)
+            return found; // no app/Commands — the only thing we swallow
+        for (const file of files) {
+            if (!/\.(ts|js|mjs)$/.test(file))
+                continue;
+            let module;
+            try {
+                module = (await import(pathToFileURL(join(dir, file)).href));
+            }
+            catch (error) {
+                // A command file that won't load is a bug you need to see, not a command
+                // that quietly doesn't exist.
+                console.error(`✗ Could not load app/Commands/${file}:`);
+                console.error(error instanceof Error ? error.message : error);
+                process.exitCode = 1;
+                continue;
+            }
+            // Any export that looks like a command counts, so one file can hold several.
+            for (const value of Object.values(module)) {
+                const candidate = value;
+                if (candidate &&
+                    typeof candidate === "object" &&
+                    typeof candidate.name === "string" &&
+                    typeof candidate.run === "function") {
+                    found.push(candidate);
+                }
+            }
+        }
+        return found;
+    }
+    /* ------------------------------- the built-ins ------------------------------ */
+    const serve = defineCommand({
+        name: "serve",
+        description: "Start the HTTP server",
+        flags: { port: flag.number({ alias: "p", description: "port to listen on" }) },
+        async run({ flags, ui }) {
+            const application = requireApp();
+            const kernel = application.bound(HttpKernel)
+                ? application.make(HttpKernel)
+                : new HttpKernel(application);
+            const hono = kernel.build();
+            const port = flags.port ?? Number(application.config().get("app.port", 3000));
+            // Imported here, not at the top: the Node server is only needed to *serve*,
+            // and the console must still load on a machine (or a Worker) that has no
+            // reason to install it.
+            const { serve: listen } = await import("@hono/node-server").catch(() => {
+                throw new Error("`keel serve` needs @hono/node-server. Install it: npm i @hono/node-server");
+            });
+            const server = listen({ fetch: hono.fetch, port }, (info) => {
+                ui.success(`${application.config().get("app.name", "Keel")} listening on http://localhost:${info.port}`);
+            });
+            // Graceful shutdown: stop accepting connections, run the app's shutdown
+            // hooks (and every provider's shutdown()), then exit. `once` so a second
+            // signal isn't swallowed if cleanup hangs — hit Ctrl-C again to force it.
+            const shutdown = async (signal) => {
+                ui.write(`\n${signal} received — shutting down…`);
+                server.close();
+                try {
+                    await application.terminate();
+                }
+                catch (err) {
+                    ui.error(`Error during shutdown: ${String(err)}`);
+                    process.exit(1);
+                }
+                process.exit(0);
+            };
+            process.once("SIGINT", () => void shutdown("SIGINT"));
+            process.once("SIGTERM", () => void shutdown("SIGTERM"));
+            // `serve` stays alive on purpose — the server is the command.
+            await new Promise(() => { });
+        },
+    });
+    const repl = defineCommand({
+        name: "repl",
+        description: "An interactive shell with the application booted",
+        async run() {
+            const { startRepl } = await import("../repl.js");
+            await startRepl(requireApp());
+        },
+    });
+    const mcp = defineCommand({
+        name: "mcp",
+        description: "Start the MCP server (Keel's docs, API, and generators, over stdio)",
+        async run() {
+            const { runMcpServer } = await import("../../mcp/server.js");
+            await runMcpServer();
+        },
+    });
+    const routes = defineCommand({
+        name: "routes",
+        description: "List registered routes",
+        run({ ui }) {
+            const rows = requireApp().make(Router).all();
+            if (!rows.length)
+                return void ui.info("No routes registered.");
+            const table = ui.table(["Method", "Path", "Handler", "Name"]);
+            for (const r of rows) {
+                const handler = Array.isArray(r.handler)
+                    ? `${r.handler[0].name}@${r.handler[1]}`
+                    : r.handler instanceof Response
+                        ? "Static"
+                        : "Closure";
+                table.row([r.methods.join("|"), r.path, handler, r.name ?? ""]);
+            }
+            table.render();
+        },
+    });
+    /* -------------------------------- generators -------------------------------- */
+    const makeController = defineCommand({
+        name: "make:controller",
+        description: "Generate a controller",
+        args: { name: arg.string({ description: "e.g. Post" }) },
+        flags: { resource: flag.boolean({ alias: "r", description: "a RESTful resource controller" }) },
+        async run({ args, flags, ui }) {
+            const cls = className(args.name, "Controller");
+            const stub = flags.resource ? resourceControllerStub(cls) : controllerStub(cls);
+            await generate(`app/Controllers/${cls}.ts`, stub, "Controller", ui);
+        },
+    });
+    const makeProvider = defineCommand({
+        name: "make:provider",
+        description: "Generate a service provider",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const cls = className(args.name, "ServiceProvider");
+            await generate(`app/Providers/${cls}.ts`, providerStub(cls), "Provider", ui);
+        },
+    });
+    const makeMiddleware = defineCommand({
+        name: "make:middleware",
+        description: "Generate an HTTP middleware",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const cls = className(args.name, "Middleware");
+            const file = cls.charAt(0).toLowerCase() + cls.slice(1);
+            await generate(`app/Http/Middleware/${file}.ts`, middlewareStub(cls), "Middleware", ui);
+        },
+    });
+    const makeFactory = defineCommand({
+        name: "make:factory",
+        description: "Generate a model factory",
+        args: { model: arg.string({ description: "e.g. User" }) },
+        async run({ args, ui }) {
+            const cls = className(args.model, "");
+            await generate(`database/factories/${cls}Factory.ts`, factoryStub(cls), "Factory", ui);
+        },
+    });
+    const makeSeeder = defineCommand({
+        name: "make:seeder",
+        description: "Generate a database seeder",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const cls = className(args.name, "Seeder");
+            await generate(`database/seeders/${cls}.ts`, seederStub(cls), "Seeder", ui);
+        },
+    });
+    const makeJob = defineCommand({
+        name: "make:job",
+        description: "Generate a queued job",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const cls = className(args.name, "Job");
+            await generate(`app/Jobs/${cls}.ts`, jobStub(cls), "Job", ui);
+        },
+    });
+    const makePage = defineCommand({
+        name: "make:page",
+        description: "Generate a page — its path is its URL: make:page users/[id]",
+        args: { path: arg.string({ description: "e.g. users/[id]" }) },
+        async run({ args, ui }) {
+            // The path IS the route, so it's used verbatim — no class-name munging.
+            const file = args.path.replace(/^\/+/, "").replace(/\.(tsx|jsx)$/, "");
+            await generate(`resources/pages/${file}.tsx`, pageStub(file), "Page", ui);
+        },
+    });
+    const makeCommand = defineCommand({
+        name: "make:command",
+        description: "Generate a console command (typed args + flags, prompts, UI)",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const file = args.name.replace(/[^a-zA-Z0-9:_-]/g, "");
+            await generate(`app/Commands/${file.replace(/:/g, "-")}.ts`, commandStub(file), "Command", ui);
+        },
+    });
+    const makeNotification = defineCommand({
+        name: "make:notification",
+        description: "Generate a notification",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const cls = className(args.name, "Notification");
+            await generate(`app/Notifications/${cls}.ts`, notificationStub(cls), "Notification", ui);
+        },
+    });
+    const makeTransformer = defineCommand({
+        name: "make:transformer",
+        description: "Generate an API transformer",
+        args: { name: arg.string() },
+        flags: { model: flag.string({ alias: "m", description: "the value it maps (e.g. User)" }) },
+        async run({ args, flags, ui }) {
+            const cls = className(args.name, "Transformer");
+            const model = flags.model ? className(flags.model, "") : cls.replace(/Transformer$/, "");
+            await generate(`app/Transformers/${cls}.ts`, transformerStub(cls, model), "Transformer", ui);
+        },
+    });
+    const makePackage = defineCommand({
+        name: "make:package",
+        description: "Scaffold a Keel package (a PackageProvider skeleton)",
+        args: { name: arg.string() },
+        async run({ args, ui }) {
+            const slug = args.name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+            const cls = slug.charAt(0).toUpperCase() + slug.slice(1);
+            await generate(`packages/${slug}/${cls}ServiceProvider.ts`, packageProviderStub(slug), "Package", ui);
+        },
+    });
+    /* -------------------------------- migrations -------------------------------- */
+    const migrate = defineCommand({
+        name: "migrate",
+        description: "Run pending database migrations (app + package)",
+        async run({ ui }) {
+            const applied = await migratorFor().up(await collectMigrations(requireApp()));
+            if (!applied.length)
+                return void ui.info("Nothing to migrate.");
+            for (const name of applied)
+                ui.success(`Migrated ${name}`);
+        },
+    });
+    const migrateRollback = defineCommand({
+        name: "migrate:rollback",
+        description: "Roll back the most recent batch of migrations",
+        async run({ ui }) {
+            const rolled = await migratorFor().down(await collectMigrations(requireApp()));
+            if (!rolled.length)
+                return void ui.info("Nothing to roll back.");
+            for (const name of rolled)
+                ui.success(`Rolled back ${name}`);
+        },
+    });
+    const migrateStatus = defineCommand({
+        name: "migrate:status",
+        description: "Show which migrations have run and which are pending",
+        async run({ ui }) {
+            const migrator = migratorFor();
+            const ran = new Set(await migrator.ran());
+            const migrations = await collectMigrations(requireApp());
+            if (!migrations.length)
+                return void ui.info("No migrations found.");
+            const table = ui.table(["Status", "Migration"]);
+            for (const m of migrations)
+                table.row([ran.has(m.name) ? "ran" : "pending", m.name]);
+            table.render();
+        },
+    });
+    const vendorPublish = defineCommand({
+        name: "vendor:publish",
+        description: "Copy package-published files (config, assets) into this app",
+        flags: {
+            tag: flag.string({ description: "only publish files under this tag" }),
+            force: flag.boolean({ description: "overwrite files that already exist" }),
+        },
+        async run({ flags, ui }) {
+            const registry = requireApp().make(PublishRegistry);
+            const entries = registry.all(flags.tag);
+            if (!entries.length) {
+                ui.info(flags.tag ? `Nothing published under tag "${flags.tag}".` : "Nothing to publish.");
+                const tags = registry.tags();
+                if (!flags.tag && tags.length)
+                    ui.info(`Available tags: ${tags.join(", ")}`);
+                return;
+            }
+            for (const entry of entries) {
+                for (const [from, to] of Object.entries(entry.files)) {
+                    await publishPath(from, to, flags.force, ui);
+                }
+            }
+        },
+    });
+    /* ---------------------------------- dispatch -------------------------------- */
+    const kernel = new ConsoleKernel({ binary: "keel" }).register(serve, repl, mcp, routes, makeController, makeProvider, makeMiddleware, makeFactory, makeSeeder, makeJob, makePage, makeCommand, makeNotification, makeTransformer, makePackage, migrate, migrateRollback, migrateStatus, vendorPublish);
+    // Package-contributed commands (a package's `commands([...])`), then the app's —
+    // registered last, so an app command of the same name overrides anything above.
+    if (app)
+        kernel.register(...app.make(CommandRegistry).all());
+    kernel.register(...(await appCommands()));
+    process.exitCode = await kernel.run(argv.slice(2));
+}

package/dist/core/cli/stubs.d.ts

@@ -8,5 +8,19 @@ export declare function factoryStub(model: string): string;
 export declare function seederStub(name: string): string;
 export declare function jobStub(name: string): string;
 export declare function notificationStub(name: string): string;
+/**
+ * A package skeleton: a `PackageProvider` wired for the common jobs — merging
+ * config, contributing a migration, mounting routes + assets, and declaring a
+ * publishable config stub. `name` is the short package name (e.g. "billing").
+ */
+export declare function packageProviderStub(name: string): string;
 /** `name` is the class (e.g. "UserTransformer"); `model` is the value it maps. */
 export declare function transformerStub(name: string, model: string): string;
+/**
+ * A page — `resources/pages/<path>.tsx`. The file's location *is* its URL, so the
+ * stub is deliberately bare: a component, and a loader only when the path takes a
+ * parameter to load anything by.
+ */
+export declare function pageStub(file: string): string;
+/** A console command — `app/Commands/<name>.ts`. */
+export declare function commandStub(name: string): string;

package/dist/core/cli/stubs.js

@@ -100,6 +100,45 @@ export class ${name} extends Notification {
 }
 `;
 }
+/**
+ * A package skeleton: a `PackageProvider` wired for the common jobs — merging
+ * config, contributing a migration, mounting routes + assets, and declaring a
+ * publishable config stub. `name` is the short package name (e.g. "billing").
+ */
+export function packageProviderStub(name) {
+    const cls = name.charAt(0).toUpperCase() + name.slice(1);
+    return `import { PackageProvider, type Router } from "@shaferllc/keel/core";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * The ${cls} package. Registered like any provider:
+ *   app.register(${cls}ServiceProvider)
+ */
+export class ${cls}ServiceProvider extends PackageProvider {
+  readonly name = "${name}";
+
+  register(): void {
+    this.mergeConfig("${name}", {
+      enabled: true,
+      path: "${name}",
+    });
+    // this.migrations([${name}Migration]);
+    this.publishes({ [join(here, "config.stub")]: "config/${name}.ts" }, "${name}-config");
+  }
+
+  boot(): void {
+    if (this.app.config().get("${name}.enabled") === false) return;
+    // Serve a bundled UI (after \`vite build\`): this.assets("${name}/assets", join(here, "ui"), { immutable: true });
+    this.routes((r: Router) => {
+      r.get("/", (c) => c.json({ package: "${name}", ok: true }));
+    }, { prefix: this.app.config().get("${name}.path", "${name}"), as: "${name}" });
+  }
+}
+`;
+}
 /** `name` is the class (e.g. "UserTransformer"); `model` is the value it maps. */
 export function transformerStub(name, model) {
     return `import { Transformer, type Attributes } from "@shaferllc/keel/core";
@@ -118,3 +157,69 @@ export class ${name} extends Transformer</* ${model} */ any> {
 }
 `;
 }
+/**
+ * A page — `resources/pages/<path>.tsx`. The file's location *is* its URL, so the
+ * stub is deliberately bare: a component, and a loader only when the path takes a
+ * parameter to load anything by.
+ */
+export function pageStub(file) {
+    const params = [...file.matchAll(/\[(?:\.\.\.)?([^\]]+)\]/g)].map((m) => m[1]);
+    const propsType = params.length
+        ? `{ ${params.map((p) => `${p}: string`).join("; ")} }`
+        : "Record<string, never>";
+    const loader = params.length
+        ? `
+export const loader = async (c: Ctx) => {
+  // Load whatever this page needs; it arrives as \`data\`.
+  return { ${params.map((p) => `${p}: c.req.param("${p}")`).join(", ")} };
+};
+`
+        : "";
+    const dataType = params.length ? propsType : "undefined";
+    // Only import Ctx when there's a loader to use it — an unused import would
+    // fail the very typecheck the generated file is supposed to pass.
+    const imports = params.length ? "Ctx, PageProps" : "PageProps";
+    return `import type { ${imports} } from "@shaferllc/keel/core";
+${loader}
+export default function Page({ params, data }: PageProps<${propsType}, ${dataType}>) {
+  void params;
+  void data;
+
+  return (
+    <main>
+      <h1>${file}</h1>
+    </main>
+  );
+}
+`;
+}
+/** A console command — `app/Commands/<name>.ts`. */
+export function commandStub(name) {
+    const varName = name.replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toLowerCase());
+    return `import { defineCommand, arg, flag } from "@shaferllc/keel/core";
+
+export const ${varName} = defineCommand({
+  name: "${name}",
+  description: "Describe what this command does",
+
+  args: {
+    // \`args.target\` is a string, inferred from this spec.
+    target: arg.string({ description: "what to act on" }),
+  },
+
+  flags: {
+    // \`flags.force\` is a boolean.
+    force: flag.boolean({ alias: "f", description: "skip the confirmation" }),
+  },
+
+  async run({ args, flags, ui, prompt }) {
+    if (!flags.force && !(await prompt.confirm(\`Really do this to \${args.target}?\`))) {
+      ui.warning("Cancelled.");
+      return 1;
+    }
+
+    ui.success(\`Done: \${args.target}\`);
+  },
+});
+`;
+}

package/dist/core/console-prompt.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Interactive prompts for console commands — ask, confirm, choice, and friends.
+ *
+ *   const name = await prompt.ask("What is your name?");
+ *   const ok = await prompt.confirm("Delete everything?");
+ *   const driver = await prompt.choice("Pick a driver", ["sqlite", "postgres"]);
+ *
+ * `node:readline` is imported dynamically, so the core still loads on the edge.
+ *
+ * ## Prompts are testable, which is the whole point
+ *
+ * A command that asks questions is normally a command you can't test. So a prompt
+ * can be **trapped**: you script the answer up front, and the prompt never
+ * touches the terminal.
+ *
+ *   const prompt = createPrompt({ trap: true });
+ *   prompt.trap("What is your name?").replyWith("Ada");
+ *   prompt.trap("Delete everything?").reject();
+ *
+ * An untrapped prompt in trap mode **throws** rather than hanging forever waiting
+ * on stdin that a test will never provide.
+ */
+export interface PromptOptions<T> {
+    /** Pressing enter accepts this. */
+    default?: T;
+    /** Shown in dim text beside the question. */
+    hint?: string;
+    /** Return true to accept, or a string explaining why not. */
+    validate?: (value: T) => true | string;
+    /** Transform the value before it's returned. */
+    result?: (value: T) => T;
+}
+export interface ChoiceOptions<T> extends PromptOptions<T> {
+    /** Show this many options at once. */
+    limit?: number;
+}
+/** A choice: a bare string, or a value with a label. */
+export type Choice = string | {
+    value: string;
+    label?: string;
+    hint?: string;
+};
+/** A scripted answer, waiting for the prompt that matches it. */
+export interface Trap {
+    /** Answer an `ask` / `secure` / `autocomplete`. */
+    replyWith(value: string): Trap;
+    /** Answer a `confirm` / `toggle` with yes. */
+    accept(): Trap;
+    /** Answer a `confirm` / `toggle` with no. */
+    reject(): Trap;
+    /** Answer a `choice` by index. */
+    chooseOption(index: number): Trap;
+    /** Answer a `multiple` by indexes. */
+    chooseOptions(indexes: number[]): Trap;
+    /** Assert the prompt's `validate` rejects this input, with this message. */
+    assertFails(value: string, message?: string): Trap;
+    /** Assert the prompt's `validate` accepts this input. */
+    assertPasses(value: string): Trap;
+}
+export interface Prompt {
+    ask(question: string, options?: PromptOptions<string>): Promise<string>;
+    /** Like `ask`, but the input isn't echoed. */
+    secure(question: string, options?: PromptOptions<string>): Promise<string>;
+    confirm(question: string, options?: PromptOptions<boolean>): Promise<boolean>;
+    /** A confirm with your own labels. */
+    toggle(question: string, labels: [string, string], options?: PromptOptions<boolean>): Promise<boolean>;
+    choice(question: string, choices: Choice[], options?: ChoiceOptions<string>): Promise<string>;
+    multiple(question: string, choices: Choice[], options?: ChoiceOptions<string[]>): Promise<string[]>;
+    autocomplete(question: string, choices: Choice[], options?: ChoiceOptions<string>): Promise<string>;
+    /** Script an answer for a question, so a test never blocks on stdin. */
+    trap(question: string): Trap;
+    /** Whether every trapped question was actually asked. */
+    assertAllTrapsUsed(): void;
+}
+export interface PromptFactoryOptions {
+    /** Answer from traps instead of the terminal. Tests set this. */
+    trap?: boolean;
+}
+export declare function createPrompt(options?: PromptFactoryOptions): Prompt;