@nakedev/go-scaffold 0.1.3 → 0.3.0

package/dist/index.js

@@ -11,15 +11,38 @@ const create_1 = require("./commands/create");
 const generate_1 = require("./commands/generate");
 const method_1 = require("./commands/method");
 const migration_1 = require("./commands/migration");
-const remove_1 = require("./commands/remove");
+const undo_1 = require("./commands/undo");
 const version_1 = require("./utils/version");
 const worker_1 = require("./commands/worker");
 const auth_1 = require("./commands/auth");
 const rbac_1 = require("./commands/rbac");
+const observability_1 = require("./commands/observability");
+const worker_wizard_1 = require("./prompts/worker-wizard");
+const auth_wizard_1 = require("./prompts/auth-wizard");
+const generate_wizard_1 = require("./prompts/generate-wizard");
+const config_1 = require("./utils/config");
+// fail is every command's catch: one place so the two non-obvious cases stay
+// consistent. @inquirer/prompts throws ExitPromptError both on Ctrl-C and when
+// stdin isn't a TTY, and its raw message ("User force closed the prompt with 0
+// null") tells a user nothing — the CI case especially, where the real problem
+// is a missing argument, not the prompt.
+function fail(err) {
+    const message = err.message ?? String(err);
+    if (err.name === "ExitPromptError") {
+        console.error(picocolors_1.default.red(process.stdin.isTTY
+            ? "aborted"
+            : "no interactive terminal to prompt on — pass every value as an argument/flag (see --help), or add --defaults"));
+    }
+    else {
+        console.error(picocolors_1.default.red(message));
+    }
+    process.exitCode = 1;
+}
 const program = new commander_1.Command();
 program
     .name("go-scaffold")
-    .description("Scaffold Gin + GORM + Postgres Go backend projects with a consistent domain-module standard")
+    .description("Scaffold Gin + GORM + Postgres Go backend projects with a consistent domain-module standard\n\n" +
+    "Run `go-scaffold` with no arguments to pick what to do from a menu. Every command below also asks for anything you don't pass as a flag.")
     .version((0, version_1.cliVersion)());
 program
     .command("create [name]")
@@ -29,7 +52,7 @@ program
     .option("--no-docker", "skip docker-compose.yml (only applies with --defaults)")
     .option("--no-openapi-docs", "skip docs/openapi.yaml (only applies with --defaults)")
     .option("--observability", "add Prometheus /metrics + OpenTelemetry tracing (only applies with --defaults; off by default)")
-    .option("--api-prefix <prefix>", 'URL prefix every route is grouped under (default "v1"; pass "" for none)')
+    .option("--api-prefix <prefix>", 'URL prefix every route is grouped under, e.g. v1 or api/v1 (default: none)')
     .action(async (name, opts) => {
     try {
         await (0, create_1.createProject)(name, {
@@ -41,55 +64,96 @@ program
         });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
+// runModuleWizard resolves everything `generate module` needs, asking for
+// whatever wasn't passed as a flag. Shared by the bare menu and by
+// `generate module` itself, so both offer the same choices — the flags exist
+// for scripting, not as the only way to reach a decision.
+//
+// --defaults is the escape hatch CI and scripts use: it takes the documented
+// defaults (minimal, no auth) and asks nothing.
+async function runModuleWizard(name, opts) {
+    let { full, auth, permission } = opts;
+    if (!opts.defaults) {
+        // read first, so "not a go-scaffold project" fails before we ask anything,
+        // and so the auth/permission questions are only asked when the project
+        // actually has the features they depend on — offering them otherwise
+        // would present a choice whose only outcome is generateModule's error.
+        const config = (0, config_1.readConfig)(process.cwd());
+        if (name === undefined)
+            name = await (0, generate_wizard_1.promptModuleName)();
+        if (full === undefined)
+            full = await (0, generate_wizard_1.promptModuleShape)();
+        if (auth === undefined && config.features.auth)
+            auth = await (0, generate_wizard_1.promptModuleAuth)();
+        if (auth && permission === undefined && config.features.rbac)
+            permission = await (0, generate_wizard_1.promptModulePermission)();
+    }
+    await (0, generate_1.generateModule)(name, { full: full ?? false, auth, permission });
+}
+// runGenerateWizard is `generate`/`g` run bare — asks which target, then
+// delegates (each subcommand still prompts for anything else it's missing,
+// e.g. the name). Pulled out to a function, not just the command's .action,
+// so the top-level bare `go-scaffold` invocation can offer the exact same
+// choice without duplicating it.
+async function runGenerateWizard() {
+    const target = await (0, prompts_1.select)({
+        message: "What do you want to generate?",
+        choices: [
+            { name: "Module (safe minimal domain; add methods explicitly)", value: "module" },
+            { name: "Method (add one endpoint to an existing module)", value: "method" },
+            { name: "Migration (reserve a timestamped up/down SQL file pair)", value: "migration" },
+        ],
+    });
+    if (target === "module") {
+        await runModuleWizard(undefined, {});
+    }
+    else if (target === "method") {
+        await (0, method_1.generateMethod)(undefined, undefined, {});
+    }
+    else {
+        await (0, migration_1.generateMigration)(undefined);
+    }
+}
 const generate = program
     .command("generate")
     .alias("g")
     .description("add to an existing go-scaffold project")
     .action(async () => {
-    // bare `generate`/`g` — ask which target, then delegate (each subcommand
-    // still prompts for anything else it's missing, e.g. the name).
     try {
-        const target = await (0, prompts_1.select)({
-            message: "What do you want to generate?",
-            choices: [
-                { name: "Module (full CRUD domain)", value: "module" },
-                { name: "Method (add one endpoint to an existing module)", value: "method" },
-                { name: "Migration (reserve a timestamped up/down SQL file pair)", value: "migration" },
-            ],
-        });
-        if (target === "module") {
-            await (0, generate_1.generateModule)(undefined, { full: true });
-        }
-        else if (target === "method") {
-            await (0, method_1.generateMethod)(undefined, undefined, {});
-        }
-        else {
-            await (0, migration_1.generateMigration)(undefined);
-        }
+        await runGenerateWizard();
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
 generate
     .command("module [name]")
     .alias("m")
-    .description("scaffold a domain module — full CRUD by default, or a bare skeleton with --no-full")
-    .option("--no-full", "minimal skeleton (model/errors/repository, no default CRUD) — add endpoints one at a time with `generate method`")
+    .description("scaffold a safe minimal domain module; opt into a CRUD skeleton with --full")
+    .option("--full", "generate a CRUD skeleton (DTO fields/business rules remain TODO); minimal is the safe default")
+    // kept working for muscle memory, hidden from help: minimal is already the
+    // default, so advertising a flag that asks for it is pure noise.
+    .addOption(new commander_1.Option("--no-full", "deprecated compatibility alias; minimal is already the default").hideHelp())
     .option("--auth", "require a valid access token for this module's routes (needs `add auth`)")
-    .option("--permission <code>", "also require this permission via authz.Require (needs `add rbac`; implies --auth)")
+    .option("--permission <code>", "also require this permission via authz.Require (needs `add rbac`; pass --auth too)")
+    .option("--defaults", "skip the prompts, use the defaults (minimal, no auth) — for CI/scripting")
     .action(async (name, opts) => {
     try {
-        await (0, generate_1.generateModule)(name, { full: opts.full, auth: opts.auth, permission: opts.permission });
+        // anything not passed as a flag gets asked for — declaring both --full
+        // and --no-full leaves opts.full undefined when neither is given, which
+        // is exactly the "not answered yet" signal runModuleWizard needs.
+        await runModuleWizard(name, {
+            full: opts.full,
+            auth: opts.auth,
+            permission: opts.permission,
+            defaults: opts.defaults,
+        });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
 generate
@@ -116,8 +180,7 @@ generate
         });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
 generate
@@ -129,73 +192,314 @@ generate
         await (0, migration_1.generateMigration)(name);
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
+    }
+});
+// confirmAdd prints what a target is about to do and asks before it happens
+// — the interactive menu is the one path where nothing was typed out loud
+// yet, so it's the one place a summary earns its keep. A direct
+// `add auth --store redis` skips this on purpose: that command line already
+// says what it does, and asking again would just be in a script's way.
+//
+// Defaults to no, like `undo`'s confirm and unlike the create wizard's. This
+// prompt lands immediately after a select, where Enter meant "choose this" a
+// keystroke ago — carrying that Enter straight through would write ~15 files
+// and patch main.go, and there is no `undo auth` to walk it back. A stray
+// Enter costs a re-run instead.
+async function confirmAdd(summaryLines, opts = {}) {
+    if (opts.yes)
+        return;
+    console.log(picocolors_1.default.bold("\nThis will:"));
+    for (const line of summaryLines)
+        console.log(`  ${picocolors_1.default.dim("•")} ${line}`);
+    console.log();
+    const proceed = await (0, prompts_1.confirm)({ message: "Proceed?", default: false });
+    if (!proceed) {
+        throw new Error("cancelled — nothing was written");
+    }
+}
+// runAddWizard is `add` run bare — asks which target, then delegates. Pulled
+// out to a function for the same reason as runGenerateWizard above: the
+// top-level bare `go-scaffold` invocation reuses it verbatim.
+async function runAddWizard() {
+    // read once, up front: every add command reads it anyway, the summary below
+    // needs to know what's already installed (e.g. whether auth's mail goes out
+    // inline or through an existing queue), and so does the menu itself.
+    const config = (0, config_1.readConfig)(process.cwd());
+    // Each add is once-only, and rbac needs auth first. Both facts are already
+    // known here, so say them in the menu rather than letting someone walk three
+    // steps and a confirmation to reach "already been added".
+    const target = await (0, prompts_1.select)({
+        message: "What do you want to add?",
+        choices: [
+            {
+                name: "Worker (background job queue, SMTP mail, cmd/worker)",
+                value: "worker",
+                disabled: config.features.worker ? "— already installed" : false,
+            },
+            {
+                name: "Auth (JWT access tokens, refresh rotation, register/login/refresh/logout/me)",
+                value: "auth",
+                disabled: config.features.auth ? "— already installed" : false,
+            },
+            {
+                name: "RBAC (roles/permissions, cached Authz middleware)",
+                value: "rbac",
+                disabled: config.features.rbac
+                    ? "— already installed"
+                    : config.features.auth
+                        ? false
+                        : "— needs `add auth` first",
+            },
+            {
+                name: "Observability (Prometheus /metrics + OpenTelemetry tracing)",
+                value: "observability",
+                disabled: config.features.observability ? "— already installed" : false,
+            },
+        ],
+    });
+    if (target === "worker") {
+        await runAddWorker(await resolveQueueBackend({}), {});
+    }
+    else if (target === "auth") {
+        // `--store` is a real fork (it decides whether Redis joins the project at
+        // all), so the menu has to ask it the same way the worker menu asks for
+        // its queue backend — a choice only reachable by knowing the flag name
+        // isn't a choice for anyone driving this from the menu.
+        await runAddAuth(await (0, auth_wizard_1.promptAuthStore)(), {});
+    }
+    else if (target === "rbac") {
+        await runAddRbac({});
+    }
+    else {
+        await runAddObservability({});
+    }
+}
+async function runAddWorker(backend, opts) {
+    await confirmAdd([
+        `add internal/platform/{queue,mail}/ and cmd/worker/ (queue backend: ${backend === "river" ? "postgres/River" : "redis/Asynq"})`,
+        backend === "river"
+            ? "no extra service to run — jobs are rows in your own Postgres"
+            : picocolors_1.default.yellow("requires Redis to be running"),
+    ], opts);
+    await (0, worker_1.addWorker)(backend);
+}
+async function runAddAuth(store, opts) {
+    const config = (0, config_1.readConfig)(process.cwd());
+    await confirmAdd([
+        "add internal/app/user/, internal/shared/middleware/auth.go, and cmd/seed",
+        store === "postgres"
+            ? "tokens + rate-limit counters: Postgres (user_svc.auth_tokens), in-process — no extra service"
+            : picocolors_1.default.yellow("tokens + rate-limit counters: Redis — requires a Redis server to be running"),
+        config.features.worker
+            ? "verification/reset mail: queued through the worker already installed"
+            : picocolors_1.default.yellow("verification/reset mail: sent inline over SMTP (no worker yet) — /auth/register and /auth/forgot-password block until it's sent"),
+    ], opts);
+    await (0, auth_1.addAuth)(store);
+}
+async function runAddRbac(opts) {
+    const config = (0, config_1.readConfig)(process.cwd());
+    if (!config.features.auth) {
+        throw new Error("`add rbac` requires `add auth` first — there's no Role claim to check permissions against otherwise");
+    }
+    await confirmAdd(["add roles/permissions admin API, cached Authz middleware, and PATCH /users/:id/set-role"], opts);
+    await (0, rbac_1.addRbac)();
+}
+async function runAddObservability(opts) {
+    await confirmAdd(["add Prometheus /metrics + OpenTelemetry tracing", "patch cmd/api/wiring.go and internal/platform/database to wire it in"], opts);
+    await (0, observability_1.addObservability)();
+}
+const add = program
+    .command("add")
+    .description("add opt-in infrastructure to an existing go-scaffold project")
+    .action(async () => {
+    try {
+        await runAddWizard();
+    }
+    catch (err) {
+        fail(err);
     }
 });
-const add = program.command("add").description("add opt-in infrastructure to an existing go-scaffold project");
 add
     .command("worker")
-    .description("add Redis, an Asynq task queue, SMTP mail, and cmd/worker (opt-in — most projects don't need this on day one)")
-    .action(async () => {
+    .description("add a background job queue, SMTP mail, and cmd/worker (opt-in — most projects don't need this on day one)")
+    .option("--queue <backend>", "where jobs are stored: postgres (River, default) or redis (Asynq)")
+    .option("--defaults", "skip the prompt, use the Postgres-backed queue")
+    .option("-y, --yes", "skip the confirmation summary")
+    .action(async (opts) => {
     try {
-        await (0, worker_1.addWorker)();
+        await runAddWorker(await resolveQueueBackend(opts), { yes: opts.yes || opts.defaults });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
+// resolveQueueBackend maps the friendly flag values people actually type
+// ("postgres", "redis") onto the adapter names, and falls back to the prompt
+// when neither --queue nor --defaults was given.
+async function resolveQueueBackend(opts) {
+    if (opts.queue) {
+        const normalized = opts.queue.trim().toLowerCase();
+        const byName = {
+            postgres: "river",
+            river: "river",
+            pg: "river",
+            redis: "asynq",
+            asynq: "asynq",
+        };
+        const backend = byName[normalized];
+        if (!backend) {
+            throw new Error(`unknown --queue ${opts.queue} — use "postgres" (River) or "redis" (Asynq)`);
+        }
+        return backend;
+    }
+    if (opts.defaults)
+        return "river";
+    return (0, worker_wizard_1.promptQueueBackend)();
+}
 add
     .command("auth")
-    .description("add email/password auth: JWT access tokens, Redis-backed refresh token rotation, register/login/refresh/logout/me (requires `add worker` first)")
-    .action(async () => {
+    .description("add email/password auth: JWT access tokens, refresh token rotation, register/login/refresh/logout/me (requires `add worker` first)")
+    .option("--store <store>", 'where tokens and rate-limit counters live: "postgres" (default, no extra service) or "redis" (exact across replicas)')
+    .option("--defaults", "skip the prompt, use the Postgres-backed store (for CI/scripting)")
+    .option("-y, --yes", "skip the confirmation summary")
+    .action(async (opts) => {
     try {
-        await (0, auth_1.addAuth)();
+        // Same shape as `add worker`: an explicit flag wins, --defaults takes
+        // the documented default silently, and anything else asks rather than
+        // picking a store the caller never saw a choice about.
+        let store;
+        if (opts.store !== undefined) {
+            const normalized = opts.store.trim().toLowerCase();
+            if (normalized !== "postgres" && normalized !== "redis") {
+                throw new Error(`unknown --store ${opts.store} — use "postgres" or "redis"`);
+            }
+            store = normalized;
+        }
+        else if (opts.defaults) {
+            store = "postgres";
+        }
+        else {
+            store = await (0, auth_wizard_1.promptAuthStore)();
+        }
+        await runAddAuth(store, { yes: opts.yes || opts.defaults });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
 add
     .command("rbac")
     .description("add role-based access control: roles/permissions admin API, cached Authz middleware, PATCH /users/:id/set-role (requires `add auth` first)")
-    .action(async () => {
+    .option("-y, --yes", "skip the confirmation summary")
+    .action(async (opts) => {
     try {
-        await (0, rbac_1.addRbac)();
+        await runAddRbac({ yes: opts.yes });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
-const remove = program
-    .command("remove")
-    .alias("rm")
-    .description("remove a domain module (deletes the package + un-wires main.go/openapi.yaml/migration)")
+add
+    .command("observability")
+    .description("add Prometheus /metrics + OpenTelemetry tracing for Gin + GORM (also available at `create` time via --observability)")
+    .option("-y, --yes", "skip the confirmation summary")
+    .action(async (opts) => {
+    try {
+        await runAddObservability({ yes: opts.yes });
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+const undo = program
+    .command("undo")
+    .description("undo a `generate module` you didn't mean to run (typo'd name, domain you decided against)")
     .action(async () => {
-    // bare `remove`/`rm` — module is the only target, so prompt for the name
+    // bare `undo` — module is the only target, so prompt for the name
+    try {
+        await (0, undo_1.undoModule)(undefined, {});
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+undo
+    .command("module [name]")
+    .alias("m")
+    .description("delete a generated module and everything it wired up, migration files included")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async (name, opts) => {
     try {
-        await (0, remove_1.removeModule)(undefined, {});
+        await (0, undo_1.undoModule)(name, { yes: opts.yes });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
+// `remove module` was this command's old name, back when it claimed to retire
+// a domain that might be live — and so kept the migration files, which for the
+// case people actually used it in (undoing a mistake) meant a typo's migration
+// ran on every database created from then on. Kept as an alias rather than
+// deleted outright: a muscle-memory `rm m` shouldn't be an unrecognised-command
+// error, and the semantics only got safer.
+const remove = program.command("remove", { hidden: true }).alias("rm");
 remove
     .command("module [name]")
     .alias("m")
-    .description("delete a domain module and reverse everything `generate module` wired up")
     .option("-y, --yes", "skip the confirmation prompt")
     .action(async (name, opts) => {
+    console.error(picocolors_1.default.yellow("`remove module` is now `undo module` — running that instead."));
     try {
-        await (0, remove_1.removeModule)(name, { yes: opts.yes });
+        await (0, undo_1.undoModule)(name, { yes: opts.yes });
     }
     catch (err) {
-        console.error(picocolors_1.default.red(err.message));
-        process.exitCode = 1;
+        fail(err);
     }
 });
-program.parseAsync(process.argv);
+// runTopMenu is bare `go-scaffold` with no arguments at all — the exact
+// command name is the one thing people forget, so give the same "ask, then
+// delegate" menu `add` and `generate` already give when run bare, instead of
+// Commander's static help text (which lists commands but never lets you act
+// on one).
+//
+// Deliberately NOT a .action() on the root command: giving the root an action
+// makes it callable, which turns a mistyped subcommand into "too many
+// arguments. Expected 0 arguments but got 2: ad, auth" instead of Commander's
+// "unknown command 'ad' (Did you mean add?)". Branching on argv keeps the
+// menu and keeps that error.
+async function runTopMenu() {
+    // Every entry but "create" needs a project. Offering them outside one buys
+    // two selects and then the same error — so say it once, up front, and only
+    // offer what can actually run here.
+    const inProject = (0, config_1.isProjectDir)(process.cwd());
+    const target = inProject
+        ? await (0, prompts_1.select)({
+            message: "What do you want to do?",
+            choices: [
+                { name: "Create a new project", value: "create" },
+                { name: "Generate (module/method/migration in an existing project)", value: "generate" },
+                { name: "Add (auth/worker/rbac/observability in an existing project)", value: "add" },
+                { name: "Undo a generated module", value: "undo" },
+            ],
+        })
+        : (console.log(picocolors_1.default.dim(`${process.cwd()} isn't a go-scaffold project — only "create" can run here.\n`)), "create");
+    if (target === "create") {
+        await (0, create_1.createProject)(undefined, {});
+    }
+    else if (target === "generate") {
+        await runGenerateWizard();
+    }
+    else if (target === "add") {
+        await runAddWizard();
+    }
+    else {
+        await (0, undo_1.undoModule)(undefined, {});
+    }
+}
+if (process.argv.length <= 2) {
+    runTopMenu().catch(fail);
+}
+else {
+    program.parseAsync(process.argv);
+}

package/dist/prompts/auth-wizard.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptAuthStore = promptAuthStore;
+const prompts_1 = require("@inquirer/prompts");
+// The one decision `add auth` cannot make for you: where refresh tokens,
+// one-time tokens and rate-limit counters live. It drives which tokenStore
+// implementation is written, whether Redis is added to the project at all,
+// and whether the auth_tokens table exists.
+//
+// Mirrors promptQueueBackend: the choice exists as `--store` for scripting,
+// but nobody should have to know the flag name to discover the option.
+async function promptAuthStore() {
+    return (0, prompts_1.select)({
+        message: "Where should refresh tokens and rate-limit counters be stored?",
+        default: "postgres",
+        choices: [
+            {
+                name: "Postgres (user_svc.auth_tokens)",
+                value: "postgres",
+                description: "no extra service to run; tokens are rows in your own database, and the rate limiter counts in-process",
+            },
+            {
+                name: "Redis",
+                value: "redis",
+                description: "TTL expiry and rate-limit counters are exact across replicas; needs a Redis server",
+            },
+        ],
+    });
+}

package/dist/prompts/create-wizard.js

@@ -29,9 +29,12 @@ async function runCreateWizard() {
         message: "Add metrics + tracing (Prometheus /metrics, OpenTelemetry over OTLP/HTTP for Gin + GORM)?",
         default: false,
     });
+    // No default, so Enter means what an empty answer looks like it means. A
+    // prefix is opt-in: it puts every route in the project behind a path segment
+    // that is then fixed for the life of the project, which is not something to
+    // acquire by not answering a question.
     const apiPrefixRaw = await (0, prompts_1.input)({
-        message: "API route prefix (e.g. v1, api/v1; leave blank for none):",
-        default: "v1",
+        message: "API route prefix — leave blank for none, or e.g. v1, api/v1:",
         validate: naming_1.validateApiPrefix,
     });
     const apiPrefix = (0, naming_1.normalizeApiPrefix)(apiPrefixRaw);

package/dist/prompts/generate-wizard.js

@@ -6,6 +6,10 @@ exports.promptMethodType = promptMethodType;
 exports.promptGetMode = promptGetMode;
 exports.promptMigrationName = promptMigrationName;
 exports.promptLookupField = promptLookupField;
+exports.promptModuleShape = promptModuleShape;
+exports.promptModuleAuth = promptModuleAuth;
+exports.promptModulePermission = promptModulePermission;
+exports.promptExistingModule = promptExistingModule;
 const prompts_1 = require("@inquirer/prompts");
 const naming_1 = require("../utils/naming");
 // wraps an assert-style validator into inquirer's true|string contract so a
@@ -74,3 +78,56 @@ async function promptLookupField() {
     });
     return field.trim();
 }
+// The three `generate module` decisions that exist as flags (--full, --auth,
+// --permission). They live here next to the other generate prompts so the
+// subcommand and the bare-menu path can ask them the same way — a choice only
+// reachable by knowing the flag name isn't a choice for anyone driving this
+// from the menu.
+async function promptModuleShape() {
+    return (0, prompts_1.select)({
+        message: "What should the module contain?",
+        default: false,
+        choices: [
+            {
+                name: "Minimal — model + wiring only",
+                value: false,
+                description: "the safe default; add endpoints one at a time with `generate method`",
+            },
+            {
+                name: "CRUD skeleton — list/get/create/update/delete",
+                value: true,
+                description: "all five endpoints wired up; DTO fields and business rules are left as TODO",
+            },
+        ],
+    });
+}
+async function promptModuleAuth() {
+    return (0, prompts_1.confirm)({
+        message: "Require a valid access token for this module's routes?",
+        default: false,
+    });
+}
+// Blank is a real answer here (auth without a specific permission), so this
+// takes no validate — an unusable code is caught by generateModule, which
+// owns the pattern and the "needs add rbac" rule.
+async function promptModulePermission() {
+    const code = await (0, prompts_1.input)({
+        message: "Also require a permission code — leave blank for none, or e.g. products:manage:",
+    });
+    return code.trim() || undefined;
+}
+// promptExistingModule picks from what's actually on disk, for the commands
+// that operate on a module that already exists (`generate method`, `undo
+// module`). Free text was the wrong control here: the package name is the one
+// form of the name nobody remembers exactly — a typo'd "ordrs" gets
+// singularized to "ordr" on the way to the error, so the message names a
+// string the user never typed.
+async function promptExistingModule(packages, action) {
+    if (packages.length === 0) {
+        throw new Error(`no modules in internal/app yet — run \`go-scaffold generate module <name>\` before trying to ${action} one`);
+    }
+    return (0, prompts_1.select)({
+        message: "Which module?",
+        choices: packages.map((pkg) => ({ name: pkg, value: pkg })),
+    });
+}

package/dist/prompts/worker-wizard.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptQueueBackend = promptQueueBackend;
+const prompts_1 = require("@inquirer/prompts");
+// The one decision `add worker` cannot make for you: where jobs live. It
+// drives which adapter is written, whether Redis is added to the project at
+// all, and whether an enqueue can join a database transaction.
+async function promptQueueBackend() {
+    return (0, prompts_1.select)({
+        message: "Where should background jobs be stored?",
+        default: "river",
+        choices: [
+            {
+                name: "Postgres (River)",
+                value: "river",
+                description: "no extra service to run; a job is only delivered if the transaction that enqueued it commits",
+            },
+            {
+                name: "Redis (Asynq)",
+                value: "asynq",
+                description: "higher throughput and shareable across languages; needs a Redis server, and an enqueue cannot join a database transaction",
+            },
+        ],
+    });
+}