@beignet/cli 0.0.1 → 0.0.4

package/dist/index.js

@@ -1,21 +1,22 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { buildApplication, buildCommand, buildRouteMap, run, text_en, } from "@stricli/core";
-import { createProject } from "./create.js";
-import { applyDoctorFixes, formatDoctor, formatRoutes, inspectApp, } from "./inspect.js";
-import { formatLint, lintApp } from "./lint.js";
-import { makeAdapter, makeContract, makeEvent, makeJob, makeListener, makePolicy, makePort, makeResource, makeSchedule, makeTest, makeUseCase, } from "./make.js";
-import { featureChoices, integrationChoices, presetChoices, } from "./templates.js";
-export { applyDoctorFixes, createProject, formatDoctor, formatLint, formatRoutes, inspectApp, lintApp, makeAdapter, makeContract, makeEvent, makeJob, makeListener, makePolicy, makePort, makeResource, makeSchedule, makeTest, makeUseCase, };
-const templateChoices = ["next"];
-const packageManagerChoices = [
-    "bun",
-    "npm",
-    "pnpm",
-    "yarn",
+import { buildApplication, buildCommand, buildRouteMap, proposeCompletions, run, text_en, } from "@stricli/core";
+import { completionShellChoices, featureChoices, integrationChoices, makeFeatureAddonChoices, packageManagerChoices, presetChoices, templateChoices, } from "./choices.js";
+import { getCliVersion } from "./version.js";
+const outputFormatChoices = [
+    "human",
+    "json",
+    "github",
 ];
 const parseString = (input) => input;
+const parsePositiveInteger = (input) => {
+    const value = Number(input);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("Expected a positive integer.");
+    }
+    return value;
+};
 const forceFlag = {
     kind: "boolean",
     optional: true,
@@ -40,13 +41,60 @@ const parsedStringFlag = (brief) => ({
     optional: true,
     brief,
 });
+const cwdFlag = parsedStringFlag("App directory to inspect. Defaults to the current working directory.");
+const formatFlag = {
+    kind: "enum",
+    values: outputFormatChoices,
+    optional: true,
+    brief: "Output format. Defaults to human, or github when GITHUB_ACTIONS=true.",
+};
 const makeFlagParameters = {
     force: forceFlag,
     dryRun: dryRunFlag,
     json: jsonFlag,
 };
-const jsonFlagParameters = {
+const routesFlagParameters = {
+    json: jsonFlag,
+    cwd: cwdFlag,
+};
+const lintFlagParameters = {
+    json: jsonFlag,
+    cwd: cwdFlag,
+    format: formatFlag,
+};
+const dbFlagParameters = {
+    json: jsonFlag,
+    dryRun: dryRunFlag,
+};
+const taskRunFlagParameters = {
+    json: jsonFlag,
+    input: parsedStringFlag("JSON input passed to the task schema."),
+    module: parsedStringFlag("Task registry module. Defaults to server/tasks.ts."),
+};
+const outboxDrainFlagParameters = {
+    json: jsonFlag,
+    module: parsedStringFlag("Outbox registry module. Defaults to server/outbox.ts."),
+    batchSize: {
+        kind: "parsed",
+        parse: parsePositiveInteger,
+        optional: true,
+        brief: "Maximum messages to claim in one drain pass.",
+    },
+};
+const scheduleRunFlagParameters = {
     json: jsonFlag,
+    module: parsedStringFlag("Schedule registry module. Defaults to server/schedules.ts."),
+    payload: parsedStringFlag("JSON payload passed to the schedule schema."),
+    id: parsedStringFlag("Provider or app schedule run ID."),
+    attempt: {
+        kind: "parsed",
+        parse: parsePositiveInteger,
+        optional: true,
+        brief: "One-based provider attempt number.",
+    },
+    scheduledAt: parsedStringFlag("Provider scheduled timestamp."),
+    triggeredAt: parsedStringFlag("Schedule trigger timestamp."),
+    source: parsedStringFlag("Provider or app source label."),
 };
 const namePositional = {
     kind: "tuple",
@@ -58,12 +106,29 @@ const namePositional = {
         },
     ],
 };
+function resolveOutputFormat(flags) {
+    if (flags.json) {
+        if (flags.format && flags.format !== "json") {
+            throw new Error(`--json conflicts with --format ${flags.format}. Pass one of them.`);
+        }
+        return "json";
+    }
+    if (flags.format)
+        return flags.format;
+    return process.env.GITHUB_ACTIONS === "true" ? "github" : "human";
+}
+function useColor() {
+    return process.stdout.isTTY === true && !process.env.NO_COLOR;
+}
 const createCommand = buildCommand({
     docs: {
         brief: "Create a new Beignet app.",
         fullDescription: `Available features: ${featureChoices.join(", ")}
 
-Available integrations: ${integrationChoices.join(", ")}`,
+Available integrations: ${integrationChoices.join(", ")}
+
+Running create on an interactive terminal without selection flags opens a
+prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
     },
     parameters: {
         flags: {
@@ -76,8 +141,8 @@ Available integrations: ${integrationChoices.join(", ")}`,
             preset: {
                 kind: "enum",
                 values: presetChoices,
-                default: "standard",
-                brief: "Starter preset to generate.",
+                optional: true,
+                brief: "Starter preset to generate. Defaults to standard.",
             },
             packageManager: {
                 kind: "enum",
@@ -85,35 +150,29 @@ Available integrations: ${integrationChoices.join(", ")}`,
                 optional: true,
                 brief: "Package manager to use in next-step commands.",
             },
-            feature: {
-                kind: "enum",
-                values: featureChoices,
-                optional: true,
-                variadic: true,
-                brief: "Add a starter feature. Repeatable.",
-            },
             features: {
                 kind: "enum",
                 values: featureChoices,
                 optional: true,
                 variadic: ",",
-                brief: "Add comma-separated starter features.",
-            },
-            integration: {
-                kind: "enum",
-                values: integrationChoices,
-                optional: true,
-                variadic: true,
-                brief: "Add a first-party integration. Repeatable.",
+                brief: "Add starter features as a comma-separated list.",
             },
             integrations: {
                 kind: "enum",
                 values: integrationChoices,
                 optional: true,
                 variadic: ",",
-                brief: "Add comma-separated first-party integrations.",
+                brief: "Add first-party integrations as a comma-separated list.",
+            },
+            yes: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Skip interactive prompts and use the defaults.",
             },
             force: forceFlag,
+            dryRun: dryRunFlag,
+            json: jsonFlag,
         },
         positional: {
             kind: "tuple",
@@ -122,28 +181,53 @@ Available integrations: ${integrationChoices.join(", ")}`,
                     parse: parseString,
                     placeholder: "directory",
                     brief: "Project directory to create.",
+                    optional: true,
                 },
             ],
         },
     },
-    async func(flags, directory) {
-        const integrations = uniqueValues([
-            ...(flags.integration ?? []),
-            ...(flags.integrations ?? []),
-        ]);
-        const result = await createProject({
-            name: directory,
-            template: flags.template,
-            preset: flags.preset,
-            features: uniqueValues([
-                ...(flags.feature ?? []),
-                ...(flags.features ?? []),
-            ]),
-            packageManager: flags.packageManager,
-            integrations,
-            force: Boolean(flags.force),
-        });
-        writeOutput(this, nextSteps(result, { integrations }));
+    loader: async () => {
+        const { createProject } = await import("./create.js");
+        const { promptCreateSelections, shouldPromptInteractively } = await import("./create-prompts.js");
+        return async function runCreate(flags, directory) {
+            let selections = {
+                directory,
+                preset: flags.preset,
+                features: flags.features,
+                integrations: flags.integrations,
+                packageManager: flags.packageManager,
+            };
+            const interactive = shouldPromptInteractively({ ...selections, yes: flags.yes }, {
+                stdin: process.stdin.isTTY === true,
+                stdout: process.stdout.isTTY === true,
+            });
+            if (interactive) {
+                const answers = await promptCreateSelections(selections);
+                if (answers === undefined) {
+                    this.process.stderr.write("Cancelled.\n");
+                    this.process.exitCode = 2;
+                    return;
+                }
+                selections = answers;
+            }
+            if (selections.directory === undefined) {
+                throw new Error("Project directory is required. Pass beignet create <directory>, or run beignet create in an interactive terminal.");
+            }
+            const integrations = uniqueValues([...(selections.integrations ?? [])]);
+            const result = await createProject({
+                name: selections.directory,
+                template: flags.template,
+                preset: selections.preset ?? "standard",
+                features: uniqueValues([...(selections.features ?? [])]),
+                packageManager: selections.packageManager,
+                integrations,
+                force: Boolean(flags.force),
+                dryRun: Boolean(flags.dryRun),
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : nextSteps(result, { integrations }));
+        };
     },
 });
 const routesCommand = buildCommand({
@@ -151,11 +235,14 @@ const routesCommand = buildCommand({
         brief: "Inspect registered Beignet routes.",
     },
     parameters: {
-        flags: jsonFlagParameters,
+        flags: routesFlagParameters,
     },
-    async func(flags) {
-        const result = await inspectApp();
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatRoutes(result));
+    loader: async () => {
+        const { formatRoutes, inspectApp } = await import("./inspect.js");
+        return async function runRoutes(flags) {
+            const result = await inspectApp({ cwd: flags.cwd });
+            writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatRoutes(result));
+        };
     },
 });
 const doctorCommand = buildCommand({
@@ -177,19 +264,35 @@ const doctorCommand = buildCommand({
                 withNegated: false,
                 brief: "Apply low-risk fixes before reporting.",
             },
+            cwd: cwdFlag,
+            format: formatFlag,
         },
     },
-    async func(flags) {
-        const fixes = flags.fix
-            ? await applyDoctorFixes({ strict: Boolean(flags.strict) })
-            : [];
-        const result = await inspectApp({ strict: Boolean(flags.strict) });
-        result.fixes = fixes;
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatDoctor(result));
-        if (result.diagnostics.some((diagnostic) => diagnostic.severity === "error" ||
-            (flags.strict && diagnostic.severity === "warning"))) {
-            this.process.exitCode = 1;
-        }
+    loader: async () => {
+        const { applyDoctorFixes, formatDoctor, formatDoctorGithub, inspectApp } = await import("./inspect.js");
+        return async function runDoctor(flags) {
+            const format = resolveOutputFormat(flags);
+            const fixes = flags.fix
+                ? await applyDoctorFixes({
+                    cwd: flags.cwd,
+                    strict: Boolean(flags.strict),
+                })
+                : [];
+            const result = await inspectApp({
+                cwd: flags.cwd,
+                strict: Boolean(flags.strict),
+            });
+            result.fixes = fixes;
+            writeOutput(this, format === "json"
+                ? JSON.stringify(result, null, 2)
+                : format === "github"
+                    ? formatDoctorGithub(result)
+                    : formatDoctor(result, { color: useColor() }));
+            if (result.diagnostics.some((diagnostic) => diagnostic.severity === "error" ||
+                (flags.strict && diagnostic.severity === "warning"))) {
+                this.process.exitCode = 1;
+            }
+        };
     },
 });
 const lintCommand = buildCommand({
@@ -197,237 +300,380 @@ const lintCommand = buildCommand({
         brief: "Check Beignet dependency direction conventions.",
     },
     parameters: {
-        flags: jsonFlagParameters,
+        flags: lintFlagParameters,
     },
-    async func(flags) {
-        const result = await lintApp();
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatLint(result));
-        if (result.diagnostics.length > 0) {
-            this.process.exitCode = 1;
-        }
+    loader: async () => {
+        const { formatLint, formatLintGithub, lintApp } = await import("./lint.js");
+        return async function runLint(flags) {
+            const format = resolveOutputFormat(flags);
+            const result = await lintApp({ cwd: flags.cwd });
+            writeOutput(this, format === "json"
+                ? JSON.stringify(result, null, 2)
+                : format === "github"
+                    ? formatLintGithub(result)
+                    : formatLint(result, { color: useColor() }));
+            if (result.diagnostics.length > 0) {
+                this.process.exitCode = 1;
+            }
+        };
     },
 });
-const makeResourceCommand = buildCommand({
+function databaseCommand(command) {
+    return buildCommand({
+        docs: {
+            brief: `Run the app's db:${command} script.`,
+        },
+        parameters: {
+            flags: dbFlagParameters,
+        },
+        loader: async () => {
+            const { runDatabaseCommand } = await import("./db.js");
+            return async function runDb(flags) {
+                const result = await runDatabaseCommand({
+                    command,
+                    captureOutput: Boolean(flags.json),
+                    dryRun: Boolean(flags.dryRun),
+                });
+                writeOutput(this, flags.json
+                    ? JSON.stringify(result, null, 2)
+                    : databaseCommandNextSteps(result));
+                if (result.exitCode !== 0) {
+                    this.process.exitCode = result.exitCode;
+                }
+            };
+        },
+    });
+}
+const dbRoutes = buildRouteMap({
     docs: {
-        brief: "Generate a feature resource.",
-    },
-    parameters: {
-        flags: makeFlagParameters,
-        positional: namePositional,
+        brief: "Run Beignet database lifecycle commands.",
     },
-    async func(flags, name) {
-        const result = await makeResource({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeResourceNextSteps(result));
+    routes: {
+        generate: databaseCommand("generate"),
+        migrate: databaseCommand("migrate"),
+        reset: databaseCommand("reset"),
+        seed: databaseCommand("seed"),
     },
 });
-const makeContractCommand = buildCommand({
+const taskRunCommand = buildCommand({
     docs: {
-        brief: "Generate a contract group.",
+        brief: "Run an app-owned operational task.",
     },
     parameters: {
-        flags: makeFlagParameters,
+        flags: taskRunFlagParameters,
         positional: namePositional,
     },
-    async func(flags, name) {
-        const result = await makeContract({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeContractNextSteps(result));
+    loader: async () => {
+        const { runAppTask } = await import("./task.js");
+        return async function runTask(flags, name) {
+            const result = await runAppTask({
+                name,
+                input: flags.input,
+                modulePath: flags.module,
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : appTaskRunNextSteps(result));
+        };
     },
 });
-const makeUseCaseCommand = buildCommand({
+const taskRoutes = buildRouteMap({
     docs: {
-        brief: "Generate a use case.",
-    },
-    parameters: {
-        flags: makeFlagParameters,
-        positional: namePositional,
+        brief: "Run Beignet app operational tasks.",
     },
-    async func(flags, name) {
-        const result = await makeUseCase({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeUseCaseNextSteps(result));
+    routes: {
+        run: taskRunCommand,
     },
 });
-const makeTestCommand = buildCommand({
+const outboxDrainCommand = buildCommand({
     docs: {
-        brief: "Generate a use case test.",
+        brief: "Run one app-owned outbox drain pass.",
     },
     parameters: {
-        flags: makeFlagParameters,
-        positional: namePositional,
+        flags: outboxDrainFlagParameters,
     },
-    async func(flags, name) {
-        const result = await makeTest({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeTestNextSteps(result));
+    loader: async () => {
+        const { runOutboxDrain } = await import("./outbox.js");
+        return async function runDrain(flags) {
+            const result = await runOutboxDrain({
+                modulePath: flags.module,
+                batchSize: flags.batchSize,
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : outboxDrainNextSteps(result));
+        };
     },
 });
-const makePortCommand = buildCommand({
+const outboxRoutes = buildRouteMap({
     docs: {
-        brief: "Generate an application port.",
+        brief: "Run Beignet outbox operations.",
+    },
+    routes: {
+        drain: outboxDrainCommand,
+    },
+});
+const scheduleRunCommand = buildCommand({
+    docs: {
+        brief: "Run an app-owned schedule.",
     },
     parameters: {
-        flags: makeFlagParameters,
+        flags: scheduleRunFlagParameters,
         positional: namePositional,
     },
-    async func(flags, name) {
-        const result = await makePort({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makePortNextSteps(result));
+    loader: async () => {
+        const { runAppSchedule } = await import("./schedule.js");
+        return async function runSchedule(flags, name) {
+            const result = await runAppSchedule({
+                name,
+                modulePath: flags.module,
+                payload: flags.payload,
+                id: flags.id,
+                attempt: flags.attempt,
+                scheduledAt: flags.scheduledAt,
+                triggeredAt: flags.triggeredAt,
+                source: flags.source,
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : scheduleRunNextSteps(result));
+        };
+    },
+});
+const scheduleRoutes = buildRouteMap({
+    docs: {
+        brief: "Run Beignet schedule operations.",
+    },
+    routes: {
+        run: scheduleRunCommand,
     },
 });
-const makeAdapterCommand = buildCommand({
+const completionShellFlagParameters = {
+    shell: {
+        kind: "enum",
+        values: completionShellChoices,
+        optional: true,
+        brief: "Shell to manage completions for. Defaults to $SHELL.",
+    },
+    json: jsonFlag,
+};
+const completionInstallCommand = buildCommand({
     docs: {
-        brief: "Generate a port adapter.",
+        brief: "Install beignet shell completions for bash or zsh.",
     },
     parameters: {
-        flags: makeFlagParameters,
-        positional: namePositional,
+        flags: completionShellFlagParameters,
     },
-    async func(flags, name) {
-        const result = await makeAdapter({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeAdapterNextSteps(result));
+    loader: async () => {
+        const { installCompletions } = await import("./completion.js");
+        return async function runInstall(flags) {
+            const result = await installCompletions({ shell: flags.shell });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : `${result.status === "updated" ? "Updated" : "Installed"} ${result.shell} completions in ${result.file}
+
+Restart your shell or source the file to activate them.`);
+        };
     },
 });
-const makePolicyCommand = buildCommand({
+const completionUninstallCommand = buildCommand({
     docs: {
-        brief: "Generate an authorization policy.",
+        brief: "Remove beignet shell completions for bash or zsh.",
     },
     parameters: {
-        flags: makeFlagParameters,
-        positional: namePositional,
+        flags: completionShellFlagParameters,
+    },
+    loader: async () => {
+        const { uninstallCompletions } = await import("./completion.js");
+        return async function runUninstall(flags) {
+            const result = await uninstallCompletions({ shell: flags.shell });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : result.status === "removed"
+                    ? `Removed ${result.shell} completions from ${result.file}`
+                    : `No beignet completions found in ${result.file}`);
+        };
+    },
+});
+const completionRoutes = buildRouteMap({
+    docs: {
+        brief: "Manage beignet shell completions.",
     },
-    async func(flags, name) {
-        const result = await makePolicy({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makePolicyNextSteps(result));
+    routes: {
+        install: completionInstallCommand,
+        uninstall: completionUninstallCommand,
     },
 });
-const makeEventCommand = buildCommand({
+const makeResourceCommand = buildCommand({
     docs: {
-        brief: "Generate a feature event.",
+        brief: "Generate a CRUD-shaped resource slice.",
     },
     parameters: {
-        flags: makeFlagParameters,
+        flags: {
+            ...makeFlagParameters,
+            auth: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Generate policy metadata and use-case authorization checks for mutating routes.",
+            },
+            tenant: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Generate tenant-scoped schemas, repository methods, and use-case checks.",
+            },
+            events: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Generate domain event definitions and publish resource events.",
+            },
+            softDelete: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Generate soft-delete persistence that archives rows with deletedAt.",
+            },
+        },
         positional: namePositional,
     },
-    async func(flags, name) {
-        const result = await makeEvent({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeEventNextSteps(result));
+    loader: async () => {
+        const { makeResource } = await import("./make.js");
+        return async function runMakeResource(flags, name) {
+            const result = await makeResource({
+                name,
+                force: Boolean(flags.force),
+                dryRun: Boolean(flags.dryRun),
+                auth: Boolean(flags.auth),
+                tenant: Boolean(flags.tenant),
+                events: Boolean(flags.events),
+                softDelete: Boolean(flags.softDelete),
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : makeResourceNextSteps(result));
+        };
     },
 });
-const makeJobCommand = buildCommand({
+const makeFeatureCommand = buildCommand({
     docs: {
-        brief: "Generate a feature job.",
+        brief: "Generate a contract-first feature slice.",
     },
     parameters: {
-        flags: makeFlagParameters,
+        flags: {
+            ...makeFlagParameters,
+            with: {
+                kind: "enum",
+                values: makeFeatureAddonChoices,
+                optional: true,
+                variadic: ",",
+                brief: "Add feature-owned artifacts. Supports policy, task/tasks, event/events, job/jobs, notification/notifications, ui, and upload/uploads.",
+            },
+        },
         positional: namePositional,
     },
-    async func(flags, name) {
-        const result = await makeJob({
-            name,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeJobNextSteps(result));
+    loader: async () => {
+        const { makeFeature } = await import("./make.js");
+        return async function runMakeFeature(flags, name) {
+            const result = await makeFeature({
+                name,
+                with: flags.with,
+                force: Boolean(flags.force),
+                dryRun: Boolean(flags.dryRun),
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : makeFeatureNextSteps(result));
+        };
     },
 });
-const makeListenerFlagParameters = {
-    ...makeFlagParameters,
-    event: parsedStringFlag("Event to listen to, for example posts/published."),
-};
+function simpleMakeCommand(generator, brief, formatNextSteps) {
+    return buildCommand({
+        docs: {
+            brief,
+        },
+        parameters: {
+            flags: makeFlagParameters,
+            positional: namePositional,
+        },
+        loader: async () => {
+            const generators = await import("./make.js");
+            return async function runMake(flags, name) {
+                const result = await generators[generator]({
+                    name,
+                    force: Boolean(flags.force),
+                    dryRun: Boolean(flags.dryRun),
+                });
+                writeOutput(this, flags.json
+                    ? JSON.stringify(result, null, 2)
+                    : formatNextSteps(result));
+            };
+        },
+    });
+}
 const makeListenerCommand = buildCommand({
     docs: {
         brief: "Generate a feature event listener.",
     },
     parameters: {
-        flags: makeListenerFlagParameters,
+        flags: {
+            ...makeFlagParameters,
+            event: parsedStringFlag("Event to listen to, for example posts/published."),
+        },
         positional: namePositional,
     },
-    async func(flags, name) {
-        if (!flags.event) {
-            throw new Error("beignet make listener requires --event feature/name, for example --event posts/published.");
-        }
-        const result = await makeListener({
-            name,
-            event: flags.event,
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeListenerNextSteps(result));
+    loader: async () => {
+        const { makeListener } = await import("./make.js");
+        return async function runMakeListener(flags, name) {
+            if (!flags.event) {
+                throw new Error("beignet make listener requires --event feature/name, for example --event posts/published.");
+            }
+            const result = await makeListener({
+                name,
+                event: flags.event,
+                force: Boolean(flags.force),
+                dryRun: Boolean(flags.dryRun),
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : makeListenerNextSteps(result));
+        };
     },
 });
-const makeScheduleFlagParameters = {
-    ...makeFlagParameters,
-    cron: parsedStringFlag("Cron expression. Defaults to 0 9 * * *."),
-    timezone: parsedStringFlag("IANA timezone, for example America/Chicago."),
-    route: {
-        kind: "boolean",
-        optional: true,
-        withNegated: false,
-        brief: "Generate a Next.js cron route for this schedule.",
-    },
-};
 const makeScheduleCommand = buildCommand({
     docs: {
         brief: "Generate a feature schedule.",
     },
     parameters: {
-        flags: makeScheduleFlagParameters,
+        flags: {
+            ...makeFlagParameters,
+            cron: parsedStringFlag("Cron expression. Defaults to 0 9 * * *."),
+            timezone: parsedStringFlag("IANA timezone, for example America/Chicago."),
+            route: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Generate a Next.js cron route for this schedule.",
+            },
+        },
         positional: namePositional,
     },
-    async func(flags, name) {
-        const result = await makeSchedule({
-            name,
-            cron: flags.cron,
-            timezone: flags.timezone,
-            route: Boolean(flags.route),
-            force: Boolean(flags.force),
-            dryRun: Boolean(flags.dryRun),
-        });
-        writeOutput(this, flags.json
-            ? JSON.stringify(result, null, 2)
-            : makeScheduleNextSteps(result));
+    loader: async () => {
+        const { makeSchedule } = await import("./make.js");
+        return async function runMakeSchedule(flags, name) {
+            const result = await makeSchedule({
+                name,
+                cron: flags.cron,
+                timezone: flags.timezone,
+                route: Boolean(flags.route),
+                force: Boolean(flags.force),
+                dryRun: Boolean(flags.dryRun),
+            });
+            writeOutput(this, flags.json
+                ? JSON.stringify(result, null, 2)
+                : makeScheduleNextSteps(result));
+        };
     },
 });
 const makeRoutes = buildRouteMap({
@@ -435,17 +681,23 @@ const makeRoutes = buildRouteMap({
         brief: "Generate Beignet app files.",
     },
     routes: {
-        adapter: makeAdapterCommand,
-        contract: makeContractCommand,
-        event: makeEventCommand,
-        job: makeJobCommand,
+        adapter: simpleMakeCommand("makeAdapter", "Generate a port adapter.", makeAdapterNextSteps),
+        contract: simpleMakeCommand("makeContract", "Generate a contract group.", makeContractNextSteps),
+        event: simpleMakeCommand("makeEvent", "Generate a feature event.", makeEventNextSteps),
+        factory: simpleMakeCommand("makeFactory", "Generate a feature test data factory.", makeFactoryNextSteps),
+        feature: makeFeatureCommand,
+        job: simpleMakeCommand("makeJob", "Generate a feature job.", makeJobNextSteps),
+        notification: simpleMakeCommand("makeNotification", "Generate a feature notification.", makeNotificationNextSteps),
         listener: makeListenerCommand,
-        policy: makePolicyCommand,
-        port: makePortCommand,
+        policy: simpleMakeCommand("makePolicy", "Generate an authorization policy.", makePolicyNextSteps),
+        port: simpleMakeCommand("makePort", "Generate an application port.", makePortNextSteps),
         resource: makeResourceCommand,
         schedule: makeScheduleCommand,
-        test: makeTestCommand,
-        useCase: makeUseCaseCommand,
+        seed: simpleMakeCommand("makeSeed", "Generate a feature seed.", makeSeedNextSteps),
+        task: simpleMakeCommand("makeTask", "Generate a feature operational task.", makeTaskNextSteps),
+        test: simpleMakeCommand("makeTest", "Generate a use case test.", makeTestNextSteps),
+        upload: simpleMakeCommand("makeUpload", "Generate a feature upload.", makeUploadNextSteps),
+        useCase: simpleMakeCommand("makeUseCase", "Generate a use case.", makeUseCaseNextSteps),
     },
 });
 const rootRoutes = buildRouteMap({
@@ -453,18 +705,26 @@ const rootRoutes = buildRouteMap({
         brief: "Beignet CLI",
         fullDescription: `Create apps, generate framework files, inspect routes, and check Beignet conventions.
 
-create-beignet <directory> is equivalent to beignet create <directory>.`,
+Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     },
     routes: {
+        completion: completionRoutes,
         create: createCommand,
+        db: dbRoutes,
         doctor: doctorCommand,
         lint: lintCommand,
         make: makeRoutes,
+        outbox: outboxRoutes,
         routes: routesCommand,
+        schedule: scheduleRoutes,
+        task: taskRoutes,
     },
 });
 const cli = buildApplication(rootRoutes, {
     name: "beignet",
+    versionInfo: {
+        currentVersion: getCliVersion(),
+    },
     scanner: {
         caseStyle: "allow-kebab-for-camel",
     },
@@ -478,7 +738,7 @@ const cli = buildApplication(rootRoutes, {
             commandErrorResult: (error) => error.message,
         },
     },
-    determineExitCode: () => 1,
+    determineExitCode: () => 2,
 });
 function uniqueValues(values) {
     return [...new Set(values)];
@@ -489,9 +749,45 @@ function writeOutput(context, output) {
 function formatCliException(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function appTaskRunNextSteps(result) {
+    const output = result.output === undefined
+        ? "undefined"
+        : JSON.stringify(result.output, null, 2);
+    return `Ran task ${result.name} in ${result.durationMs}ms
+
+Output:
+${output}`;
+}
+function outboxDrainNextSteps(result) {
+    return `Drained outbox in ${result.durationMs}ms
+
+Result:
+  claimed: ${result.result.claimed}
+  delivered: ${result.result.delivered}
+  retried: ${result.result.retried}
+  deadLettered: ${result.result.deadLettered}`;
+}
+function scheduleRunNextSteps(result) {
+    return `Ran schedule ${result.name} in ${result.durationMs}ms
+
+Run:
+  source: ${result.run.source}
+  id: ${result.run.id ?? "none"}
+  attempt: ${result.run.attempt ?? "none"}
+  scheduledAt: ${result.run.scheduledAt ?? "none"}
+  triggeredAt: ${result.run.triggeredAt ?? "none"}`;
+}
 function nextSteps(result, options = {}) {
+    if (result.dryRun) {
+        const plannedFiles = result.files.map((file) => `  ${file}`).join("\n");
+        return `Would create ${result.name} at ${result.targetDir}
+
+Planned files:
+${plannedFiles}`;
+    }
     const pm = result.packageManager;
     const run = pm === "npm" ? "npm run" : `${pm} run`;
+    const cli = packageRunnerFromPackageManager(pm);
     const envFileStep = result.files.includes(".env.example")
         ? "  cp .env.example .env.local\n"
         : "";
@@ -499,218 +795,232 @@ function nextSteps(result, options = {}) {
     const envStep = envRequiredIntegrations.length > 0
         ? "  Fill .env.local for selected provider integrations before starting the app.\n"
         : "";
+    const hasDatabase = result.files.some((file) => file.startsWith("infra/db/"));
+    const databaseStep = hasDatabase
+        ? `
+Prepare the database:
+  ${cli} db generate
+  ${cli} db migrate
+`
+        : "";
+    const featureDatabaseSteps = hasDatabase
+        ? `
+  ${cli} db generate
+  ${cli} db migrate`
+        : "";
     return `Created ${result.name} at ${result.targetDir}
 
 Next steps:
   cd ${result.targetDir}
   ${pm} install
-${envFileStep}${envStep}\
-  ${run} dev`;
+${envFileStep}${envStep}${databaseStep}
+Start the app:
+  ${run} dev
+
+Inspect the app:
+  ${cli} routes
+  ${cli} lint
+  ${cli} doctor
+
+Generate a feature:
+  ${cli} make feature projects${featureDatabaseSteps}
+  ${run} test
+  ${run} typecheck
+  ${cli} lint
+  ${cli} doctor`;
+}
+function packageRunnerFromPackageManager(pm) {
+    switch (pm) {
+        case "npm":
+            return "npm run beignet --";
+        case "pnpm":
+            return "pnpm beignet";
+        case "yarn":
+            return "yarn beignet";
+        default:
+            return "bun beignet";
+    }
 }
 function isEnvRequiredProviderIntegration(integration) {
     return (integration === "inngest" ||
         integration === "resend" ||
         integration === "upstash-rate-limit");
 }
-function makeResourceNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} resource in ${result.targetDir}
+function changedFileLines(result) {
+    return {
+        changedFiles: [...result.createdFiles, ...result.updatedFiles]
+            .map((file) => `  ${file}`)
+            .join("\n"),
+        skippedFiles: result.skippedFiles.map((file) => `  ${file}`).join("\n"),
+    };
+}
+function makeNextSteps(result, noun, steps) {
+    const { changedFiles, skippedFiles } = changedFileLines(result);
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} ${noun} in ${result.targetDir}
 
 Changed files:
 ${changedFiles || "  none"}
 ${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
 
 Next steps:
-  Review the generated schemas and repository fields.
-  Run your app's typecheck and test commands.`;
+${steps.map((step) => `  ${step}`).join("\n")}`;
 }
-function makeContractNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} contract in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+function makeResourceNextSteps(result) {
+    return makeNextSteps(result, "resource", [
+        "Use make resource when the feature maps cleanly to a REST resource with repository-backed persistence.",
+        "Review the generated schemas and repository fields.",
+        "If this app uses Drizzle, run beignet db generate and beignet db migrate so the new schema is ready.",
+        "Run your app's test and typecheck commands, then beignet lint and beignet doctor.",
+    ]);
+}
+function databaseCommandNextSteps(result) {
+    const command = [result.runner, ...result.args].join(" ");
+    const prefix = result.dryRun ? "Would run" : "Ran";
+    return `${prefix} ${result.script} in ${result.cwd}
 
-Next steps:
-  Add route handlers for the generated contracts.
-  Register the exported contract list with OpenAPI if this app publishes docs.`;
+Command:
+  ${command}`;
+}
+function makeFeatureNextSteps(result) {
+    return makeNextSteps(result, "feature slice", [
+        "Use make feature for product capabilities and workflows. Use make resource when the concept is mostly CRUD-shaped.",
+        "Treat the generated name field as a placeholder and shape the contracts, use cases, and repository around the feature's real workflow.",
+        "If this app uses Drizzle, run beignet db generate and beignet db migrate so the new schema is ready.",
+        "Run your app's test and typecheck commands, then beignet lint and beignet doctor.",
+    ]);
+}
+function makeContractNextSteps(result) {
+    return makeNextSteps(result, "contract", [
+        "Add route handlers for the generated contracts.",
+        "Register the exported contract list with OpenAPI if this app publishes docs.",
+    ]);
+}
+function makeTaskNextSteps(result) {
+    return makeNextSteps(result, "task", [
+        "Replace the starter input schema and handler with the operational workflow.",
+        "Keep business rules in use cases and call them from the task handler.",
+    ]);
 }
 function makeUseCaseNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} use case in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter input and output schemas with domain-specific shapes.
-  Add a focused use case test before wiring it to an HTTP route.`;
+    return makeNextSteps(result, "use case", [
+        "Replace the starter input and output schemas with domain-specific shapes.",
+        "Add a focused use case test before wiring it to an HTTP route.",
+    ]);
 }
 function makeTestNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} test in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter input, context, and assertion with behavior-specific coverage.
-  Run your app's test command.`;
+    return makeNextSteps(result, "test", [
+        "Replace the starter input, context, and assertion with behavior-specific coverage.",
+        "Run your app's test command.",
+    ]);
 }
 function makePortNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} port in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter execute method with domain-specific operations.
-  Replace the generated infrastructure stub with a real port adapter.`;
+    return makeNextSteps(result, "port", [
+        "Replace the starter execute method with domain-specific operations.",
+        "Replace the generated infrastructure stub with a real port adapter.",
+    ]);
 }
 function makePolicyNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} policy in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter abilities with domain-specific authorization rules.
-  Register the policy with createGate(...) and bind it in request context.`;
+    return makeNextSteps(result, "policy", [
+        "Replace the starter abilities with domain-specific authorization rules.",
+        "Register the policy with createGate(...) and bind it in request context.",
+    ]);
 }
 function makeAdapterNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} port adapter in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the generated throwing implementation with real infrastructure code.
-  Keep the adapter behind the port interface so use cases stay infrastructure-agnostic.`;
+    return makeNextSteps(result, "port adapter", [
+        "Replace the generated throwing implementation with real infrastructure code.",
+        "Keep the adapter behind the port interface so use cases stay infrastructure-agnostic.",
+    ]);
 }
 function makeEventNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} event in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter payload schema with the domain fact shape.
-  Emit the event from a use case with .emits(...) and events.record(...).`;
+    return makeNextSteps(result, "event", [
+        "Replace the starter payload schema with the domain fact shape.",
+        "Emit the event from a use case with .emits(...) and events.record(...).",
+    ]);
 }
 function makeJobNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} job in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter payload and handler with the real background work.
-  Dispatch the job through ctx.ports.jobs from a use case, listener, or schedule.`;
+    return makeNextSteps(result, "job", [
+        "Replace the starter payload and handler with the real background work.",
+        "Dispatch the job through ctx.ports.jobs from a use case, listener, or schedule.",
+    ]);
+}
+function makeFactoryNextSteps(result) {
+    return makeNextSteps(result, "factory", [
+        "Replace the starter defaults with realistic test data for this feature.",
+        "Persist through app-owned repository ports so tests avoid raw database clients.",
+    ]);
+}
+function makeSeedNextSteps(result) {
+    return makeNextSteps(result, "seed", [
+        "Replace the starter record with idempotent local or demo data.",
+        "Import the feature seed from your app-owned database seed entrypoint and run it with runSeeds(...).",
+    ]);
+}
+function makeNotificationNextSteps(result) {
+    return makeNextSteps(result, "notification", [
+        "Replace the starter payload and channels with the real user-facing message.",
+        "Send the notification through ctx.ports.notifications so delivery can run inline in tests and through jobs in production.",
+    ]);
 }
 function makeListenerNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} listener in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter handler with the event reaction.
-  Register the listener collection from infrastructure startup.`;
+    return makeNextSteps(result, "listener", [
+        "Replace the starter handler with the event reaction.",
+        "Register the listener collection from infrastructure startup.",
+    ]);
 }
 function makeScheduleNextSteps(result) {
-    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
-        .map((file) => `  ${file}`)
-        .join("\n");
-    const skippedFiles = result.skippedFiles
-        .map((file) => `  ${file}`)
-        .join("\n");
-    return `${result.dryRun ? "Would create" : "Created"} ${result.name} schedule in ${result.targetDir}
-
-Changed files:
-${changedFiles || "  none"}
-${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
-
-Next steps:
-  Replace the starter payload and handler with the scheduled workflow.
-  Trigger it from a cron route, worker, or provider adapter.`;
+    return makeNextSteps(result, "schedule", [
+        "Replace the starter payload and handler with the scheduled workflow.",
+        "Trigger it from a cron route, worker, or provider adapter.",
+    ]);
+}
+function makeUploadNextSteps(result) {
+    return makeNextSteps(result, "upload", [
+        "Replace the starter metadata, constraints, key, authorization, and onComplete behavior.",
+        "Register the upload in createUploadRouter(...) and expose it with createUploadRoute(...).",
+    ]);
 }
 export async function main(inputs = process.argv.slice(2), context = { process }) {
     if (inputs.length === 0) {
         await run(cli, ["--help"], context);
-        context.process.exitCode = 1;
+        context.process.exitCode = 2;
+        return;
+    }
+    // Shell completion scripts call `beignet completion propose <words...>`.
+    // Handle it before stricli parses the inputs: the trailing words are a
+    // partial command line, not flags for this CLI.
+    if (inputs[0] === "completion" && inputs[1] === "propose") {
+        await writeCompletionProposals(inputs.slice(2), context);
         return;
     }
     await run(cli, inputs, context);
     normalizeExitCode(context.process);
 }
+async function writeCompletionProposals(inputs, context) {
+    try {
+        const proposals = await proposeCompletions(cli, inputs.length === 0 ? [""] : inputs, context);
+        for (const proposal of proposals) {
+            context.process.stdout.write(`${proposal.completion}\n`);
+        }
+    }
+    catch {
+        // Completion failures must never break the shell; propose nothing.
+    }
+}
+// Stricli reports usage and internal failures as negative ExitCode values
+// (-5..-1). Node keeps the negative value on process.exitCode while Bun wraps
+// it to 251..255 on assignment, so both forms map to the usage exit code.
+const stricliErrorExitCodes = new Set([
+    -5, -4, -3, -2, -1, 251, 252, 253, 254, 255,
+]);
 function normalizeExitCode(proc) {
-    if (typeof proc.exitCode === "number" &&
-        (proc.exitCode < 0 || proc.exitCode > 127)) {
+    if (typeof proc.exitCode !== "number") {
+        return;
+    }
+    if (stricliErrorExitCodes.has(proc.exitCode)) {
+        proc.exitCode = 2;
+        return;
+    }
+    if (proc.exitCode > 127) {
         proc.exitCode = 1;
     }
 }
@@ -729,7 +1039,7 @@ function isCliEntrypoint() {
 if (isCliEntrypoint()) {
     main().catch((error) => {
         console.error(error instanceof Error ? error.message : String(error));
-        process.exitCode = 1;
+        process.exitCode = 2;
     });
 }
 //# sourceMappingURL=index.js.map