zudojs-cli 2.0.1 → 2.1.0

package/dist/src/generators/integration/integrationGenerator.core.js

@@ -3,7 +3,7 @@
  *
  * @module generators/integration
  */
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { mergeBarrelExport, writeFileTree, } from "../../utils/utils.fileSystem.js";
 import { renderDatabaseEnv } from "../../adapters/databases/databaseAdapter.resolver.js";
@@ -33,6 +33,18 @@ export class IntegrationGenerator {
         const configDir = `${this.getBackendPath(context)}src/configs`;
         files[`${configDir}/cors.ts`] = this.generateCorsConfig(context);
         files[`${configDir}/index.ts`] = mergeBarrelExport(context.projectPath, `${configDir}/index.ts`, `export { corsConfig } from "./cors.js";`);
+        // The generated server enforces CORS_ORIGINS (empty: no browser
+        // origin allowed), so the frontend's dev origin must be listed there or
+        // every cross-origin call from it is refused.
+        const backendEnv = `${this.getBackendPath(context)}.env.example`;
+        const backendEnvPath = join(context.projectPath, backendEnv);
+        if (existsSync(backendEnvPath)) {
+            const origins = this.frontendOrigins(context).join(",");
+            const current = readFileSync(backendEnvPath, "utf-8");
+            if (/^CORS_ORIGINS=$/m.test(current)) {
+                files[backendEnv] = current.replace(/^CORS_ORIGINS=$/m, `CORS_ORIGINS=${origins}`);
+            }
+        }
         // Development proxy configuration (belongs to the frontend app). The
         // frontend adapter has already written a vite.config.ts carrying the
         // framework plugin and path aliases; overwriting it with this minimal
@@ -59,10 +71,22 @@ export class IntegrationGenerator {
             // written anywhere, so nothing downstream could agree with the CORS
             // origins generated from the same value.
             `FRONTEND_PORT=${frontendPort}`,
+            `CORS_ORIGINS=${this.frontendOrigins(context).join(",")}`,
             `VITE_API_URL=http://localhost:${backendPort}`,
             "",
             "# Database",
-            renderDatabaseEnv(context.project.backend?.database, "mydb"),
+            // The database docker-compose.yml creates (it was "mydb").
+            renderDatabaseEnv(context.project.backend?.database, context.project.name),
+            // Empty, never a placeholder such as "change-me": docker-compose.yml
+            // refuses to start until it is set. Hex keeps it valid in a URL.
+            ...(context.project.backend?.database === "sqlite"
+                ? []
+                : [
+                    "# Password for the docker-compose.yml database; generate with: openssl rand -hex 32",
+                    context.project.backend?.database === "mysql"
+                        ? "MYSQL_ROOT_PASSWORD="
+                        : "POSTGRES_PASSWORD=",
+                ]),
             "",
         ];
         if (context.project.frontend?.framework === "next") {
@@ -167,6 +191,11 @@ export const api = {
         }
         return "apps/web/src/services/api-client.ts";
     }
+    /** Origins the frontend dev server is reached on. */
+    frontendOrigins(context) {
+        const port = context.frontendPort ?? 5173;
+        return [`http://localhost:${port}`, `http://127.0.0.1:${port}`];
+    }
     generateCorsConfig(context) {
         const frontendPort = context.frontendPort ?? 5173;
         return `/**

package/dist/src/generators/module/module.generator.js

@@ -7,10 +7,14 @@
  */
 import { basename, dirname } from "node:path";
 import { mergeBarrelExport, writeFileTree } from "../../utils/utils.fileSystem.js";
-import { CLIGenerationError } from "../../errors/index.js";
+import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
 import { assertGeneratableName, toPascalCase } from "../../utils/utils.name.js";
 import { moduleSpec, renderModuleFile } from "../../templates/shared/appRuntime.template.js";
 import { registerModuleInApp } from "./module.registration.js";
+import { moduleRoutesWiring, renderModuleRoutesIndex, } from "../../templates/backendApp/index.js";
+import { MARKERS, applyMarkerEdits, conflictingImport } from "../../wiring/index.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 export async function generateModule(options, cwd) {
     const basePath = options.basePath ?? "modules";
     const name = assertGeneratableName(options.name, "module name");
@@ -34,8 +38,21 @@ export class ${namePascal}Feature {
         files[`${basePath}/${name}/features/index.ts`] = `export { ${namePascal}Feature } from "./${featureName}.js";
 `;
     }
+    // A module gets its own routes index, registered with the app's
+    // src/routes/index.ts, when the app has one (every app `create` writes).
+    const appSrc = dirname(basePath);
+    const appRoutes = `${appSrc}/routes/index.ts`;
+    const routes = moduleRoutesWiring(name);
+    const hasAppRoutes = existsSync(join(cwd, appRoutes));
+    const clash = hasAppRoutes ? conflictingImport(cwd, appRoutes, routes.importLine) : undefined;
+    if (clash !== undefined) {
+        throw new CLIValidationError(`${appRoutes} already imports ${routes.functionName} (${clash.trim()}), so module "${name}" cannot register its routes. Choose another name.`);
+    }
+    if (hasAppRoutes) {
+        files[`${basePath}/${name}/routes/index.ts`] = renderModuleRoutesIndex(routes.functionName, "../../../container.js");
+    }
     if (options.dryRun) {
-        return Object.keys(files);
+        return hasAppRoutes ? [...Object.keys(files), appRoutes] : Object.keys(files);
     }
     try {
         await writeFileTree(cwd, files);
@@ -43,9 +60,24 @@ export class ${namePascal}Feature {
     catch (error) {
         throw new CLIGenerationError(`Failed to generate module: ${name}`, error);
     }
+    const routeEdits = hasAppRoutes
+        ? await applyMarkerEdits(cwd, [
+            { file: appRoutes, marker: MARKERS.routeImports, line: routes.importLine },
+            { file: appRoutes, marker: MARKERS.routes, line: routes.entryLine },
+        ])
+        : undefined;
     const appPath = `${dirname(basePath)}/app.ts`;
     const registration = registerModuleInApp(cwd, appPath, spec.className, `./${basename(basePath)}/index.js`);
-    options.onRegistered?.(registration);
-    return registration.registered ? [...Object.keys(files), appPath] : Object.keys(files);
+    options.onRegistered?.(routeEdits && routeEdits.manualSteps.length > 0
+        ? {
+            registered: registration.registered,
+            manualSteps: [...registration.manualSteps, ...routeEdits.manualSteps],
+        }
+        : registration);
+    return [
+        ...Object.keys(files),
+        ...(registration.registered ? [appPath] : []),
+        ...(routeEdits?.edited ?? []),
+    ];
 }
 //# sourceMappingURL=module.generator.js.map

package/dist/src/generators/resource/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Resource generator: `generate resource|route|controller|repository|dto`.
+ */
+export * from "./resource.plan.js";
+export * from "./resource.generator.js";
+export * from "./resource.layout.js";
+export * from "./resource.run.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/generators/resource/index.js

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Resource generator: `generate resource|route|controller|repository|dto`.
+ */
+export * from "./resource.plan.js";
+export * from "./resource.generator.js";
+export * from "./resource.layout.js";
+export * from "./resource.run.js";
+//# sourceMappingURL=index.js.map

package/dist/src/generators/resource/resource.generator.d.ts

@@ -0,0 +1,27 @@
+/**
+ * zudojs-cli — Resource generator.
+ *
+ * Writes the files of a resource-family schematic (see `resource.plan.ts`)
+ * and wires them: the routes are registered between the markers of the
+ * nearest `routes/index.ts`, and the controller is constructed once, in the
+ * app's `src/container.ts`. Running it twice for the same name fails with
+ * the files that already exist; it never duplicates a registration.
+ */
+import { type ResourceLayout } from "../../templates/resource/index.js";
+import { type ResourceSchematic } from "./resource.plan.js";
+/** Options for {@link generateResource}. */
+export interface GenerateResourceOptions {
+    readonly name: string;
+    readonly schematic: ResourceSchematic;
+    readonly layout: ResourceLayout;
+    readonly dryRun?: boolean;
+    /** Overwrite the schematic's own files when they exist. */
+    readonly force?: boolean;
+}
+/** What {@link generateResource} wrote and what is left to do by hand. */
+export interface ResourceGenerationResult {
+    readonly files: readonly string[];
+    readonly manualSteps: readonly string[];
+}
+export declare function generateResource(options: GenerateResourceOptions, cwd: string): Promise<ResourceGenerationResult>;
+//# sourceMappingURL=resource.generator.d.ts.map

package/dist/src/generators/resource/resource.generator.js

@@ -0,0 +1,87 @@
+/**
+ * zudojs-cli — Resource generator.
+ *
+ * Writes the files of a resource-family schematic (see `resource.plan.ts`)
+ * and wires them: the routes are registered between the markers of the
+ * nearest `routes/index.ts`, and the controller is constructed once, in the
+ * app's `src/container.ts`. Running it twice for the same name fails with
+ * the files that already exist; it never duplicates a registration.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CLIValidationError } from "../../errors/index.js";
+import { renderHttpUtils } from "../../templates/backendApp/index.js";
+import { hasPrismaModel, joinPath, renderPrismaModel, renderResourceLayers, resourceLayerPaths, resourceNames, resourceWiring, } from "../../templates/resource/index.js";
+import { writeFileTree } from "../../utils/utils.fileSystem.js";
+import { MARKERS, applyMarkerEdits, conflictingImport, } from "../../wiring/index.js";
+import { planResource } from "./resource.plan.js";
+export async function generateResource(options, cwd) {
+    const names = resourceNames(options.name);
+    const { layout } = options;
+    const plan = planResource(options.schematic);
+    const exists = (path) => existsSync(join(cwd, path));
+    const primaryPaths = plan.primary.flatMap((layer) => resourceLayerPaths(names, layout, layer));
+    const taken = primaryPaths.filter(exists);
+    if (taken.length > 0 && options.force !== true) {
+        throw new CLIValidationError(`${options.schematic} "${names.slug}" already exists:\n${taken
+            .map((path) => `  - ${path}`)
+            .join("\n")}\nChoose another name, or re-run with --force to regenerate these files.`);
+    }
+    const wiring = resourceWiring(names, layout);
+    if (plan.register && exists(wiring.container)) {
+        const container = readFileSync(join(cwd, wiring.container), "utf-8");
+        if (container.includes(`${wiring.containerKey}:`) && taken.length === 0) {
+            throw new CLIValidationError(`${wiring.container} already constructs "${wiring.containerKey}" (a resource named "${names.slug}" exists elsewhere in this app). Choose another name.`);
+        }
+    }
+    const clash = plan.register
+        ? conflictingImport(cwd, wiring.routesIndex, wiring.routeImport)
+        : undefined;
+    if (clash !== undefined) {
+        throw new CLIValidationError(`${wiring.routesIndex} already imports the routes function ${options.schematic} "${names.slug}" would register (${clash.trim()}). Choose another name.`);
+    }
+    const missingRequired = plan.required.filter((layer) => resourceLayerPaths(names, layout, layer).some((path) => !exists(path)));
+    const files = renderResourceLayers(names, layout, [
+        ...missingRequired,
+        ...plan.primary,
+    ]);
+    // Older projects have no src/utils/http.ts, which controllers import.
+    const httpUtils = joinPath(layout.appSrc, "utils", "http.ts");
+    if ((plan.primary.includes("controller") || missingRequired.includes("controller")) &&
+        !exists(httpUtils)) {
+        files[httpUtils] = renderHttpUtils();
+    }
+    const writesRepository = plan.primary.includes("repository") || missingRequired.includes("repository");
+    const schemaPath = joinPath(layout.appRoot, "prisma", "schema.prisma");
+    if (layout.prisma && writesRepository && exists(schemaPath)) {
+        const schema = readFileSync(join(cwd, schemaPath), "utf-8");
+        if (!hasPrismaModel(schema, names.entity)) {
+            files[schemaPath] = `${schema.replace(/\n*$/, "\n")}${renderPrismaModel(names)}`;
+        }
+    }
+    const edits = plan.register
+        ? [
+            { file: wiring.routesIndex, marker: MARKERS.routeImports, line: wiring.routeImport },
+            { file: wiring.routesIndex, marker: MARKERS.routes, line: wiring.routeEntry },
+            ...wiring.containerImports.map((line) => ({
+                file: wiring.container,
+                marker: MARKERS.containerImports,
+                line,
+            })),
+            { file: wiring.container, marker: MARKERS.container, line: wiring.containerEntry },
+        ]
+        : [];
+    if (!options.dryRun) {
+        await writeFileTree(cwd, files);
+    }
+    const outcome = await applyMarkerEdits(cwd, edits, options.dryRun === true);
+    const manualSteps = [...outcome.manualSteps];
+    if (layout.prisma && writesRepository) {
+        manualSteps.push(`Run "prisma migrate dev --name add-${names.slug}" (the ${names.entity} model was added to ${schemaPath}).`);
+    }
+    return {
+        files: [...Object.keys(files), ...outcome.edited],
+        manualSteps,
+    };
+}
+//# sourceMappingURL=resource.generator.js.map

package/dist/src/generators/resource/resource.layout.d.ts

@@ -0,0 +1,26 @@
+/**
+ * zudojs-cli — Where `generate` puts a resource in each architecture.
+ *
+ * - monolith / modular monolith: the app is the project root (`apps/api`
+ *   in a fullstack workspace); `--module <name>` places the resource in
+ *   `src/modules/<name>/` and registers it in that module's routes index.
+ * - microservice: the gateway app, or `apps/services/<name>` with
+ *   `--service <name>`; `--module` works inside that app the same way.
+ */
+import { type ResourceLayout } from "../../templates/resource/index.js";
+/** Inputs of {@link resolveResourceLayout}. */
+export interface ResourceLayoutInput {
+    readonly cwd: string;
+    readonly architecture: string | undefined;
+    /** `""` or `"apps/api"`: where a non-microservice backend lives. */
+    readonly backendRoot: string;
+    readonly service?: string;
+    readonly module?: string;
+}
+/**
+ * Resolves the {@link ResourceLayout} for a generate call.
+ *
+ * @throws {CLIValidationError} When the selected service or module does not exist.
+ */
+export declare function resolveResourceLayout(input: ResourceLayoutInput): ResourceLayout;
+//# sourceMappingURL=resource.layout.d.ts.map

package/dist/src/generators/resource/resource.layout.js

@@ -0,0 +1,46 @@
+/**
+ * zudojs-cli — Where `generate` puts a resource in each architecture.
+ *
+ * - monolith / modular monolith: the app is the project root (`apps/api`
+ *   in a fullstack workspace); `--module <name>` places the resource in
+ *   `src/modules/<name>/` and registers it in that module's routes index.
+ * - microservice: the gateway app, or `apps/services/<name>` with
+ *   `--service <name>`; `--module` works inside that app the same way.
+ */
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CLIValidationError } from "../../errors/index.js";
+import { joinPath } from "../../templates/resource/index.js";
+/**
+ * Resolves the {@link ResourceLayout} for a generate call.
+ *
+ * @throws {CLIValidationError} When the selected service or module does not exist.
+ */
+export function resolveResourceLayout(input) {
+    const { cwd } = input;
+    let appRoot = input.backendRoot;
+    if (input.architecture === "microservice") {
+        appRoot =
+            input.service === undefined || input.service === "gateway"
+                ? "apps/gateway"
+                : `apps/services/${input.service}`;
+        if (!existsSync(join(cwd, appRoot, "package.json"))) {
+            throw new CLIValidationError(`No app at ${appRoot}. Pass --service with an existing service (or omit it for the gateway).`);
+        }
+    }
+    const appSrc = joinPath(appRoot, "src");
+    let base = appSrc;
+    if (input.module !== undefined) {
+        base = joinPath(appSrc, "modules", input.module);
+        if (!existsSync(join(cwd, base))) {
+            throw new CLIValidationError(`Module "${input.module}" does not exist at ${base}. Create it first: zudojs generate module ${input.module}`);
+        }
+    }
+    return {
+        base,
+        appSrc,
+        appRoot,
+        prisma: existsSync(join(cwd, appRoot, "prisma", "schema.prisma")),
+    };
+}
+//# sourceMappingURL=resource.layout.js.map

package/dist/src/generators/resource/resource.plan.d.ts

@@ -0,0 +1,27 @@
+/**
+ * zudojs-cli — Which files a resource-family schematic writes.
+ *
+ * `resource`, `route`, `controller`, `repository` and `dto` all write part
+ * of the same DTO → repository → service → controller → routes chain. Each
+ * writes its own layer ("primary") and any lower layer that does not exist
+ * yet ("required"), so whatever it writes compiles on its own:
+ * `generate controller users` also writes the users service, repository
+ * and DTO when they are missing, and never touches them when they exist.
+ */
+import type { ResourceLayer } from "../../templates/resource/index.js";
+/** Schematics served by the resource generator. */
+export declare const RESOURCE_SCHEMATICS: readonly ["resource", "route", "controller", "repository", "dto"];
+/** A schematic served by the resource generator. */
+export type ResourceSchematic = (typeof RESOURCE_SCHEMATICS)[number];
+/** Whether `schematic` is served by the resource generator. */
+export declare function isResourceSchematic(schematic: string): schematic is ResourceSchematic;
+/** The layers a schematic owns, and the ones it needs underneath. */
+export interface ResourcePlan {
+    readonly primary: readonly ResourceLayer[];
+    readonly required: readonly ResourceLayer[];
+    /** Whether the routes are registered and the controller constructed. */
+    readonly register: boolean;
+}
+/** The {@link ResourcePlan} of each schematic. */
+export declare function planResource(schematic: ResourceSchematic): ResourcePlan;
+//# sourceMappingURL=resource.plan.d.ts.map

package/dist/src/generators/resource/resource.plan.js

@@ -0,0 +1,46 @@
+/**
+ * zudojs-cli — Which files a resource-family schematic writes.
+ *
+ * `resource`, `route`, `controller`, `repository` and `dto` all write part
+ * of the same DTO → repository → service → controller → routes chain. Each
+ * writes its own layer ("primary") and any lower layer that does not exist
+ * yet ("required"), so whatever it writes compiles on its own:
+ * `generate controller users` also writes the users service, repository
+ * and DTO when they are missing, and never touches them when they exist.
+ */
+/** Schematics served by the resource generator. */
+export const RESOURCE_SCHEMATICS = [
+    "resource",
+    "route",
+    "controller",
+    "repository",
+    "dto",
+];
+/** Whether `schematic` is served by the resource generator. */
+export function isResourceSchematic(schematic) {
+    return RESOURCE_SCHEMATICS.includes(schematic);
+}
+/** The {@link ResourcePlan} of each schematic. */
+export function planResource(schematic) {
+    switch (schematic) {
+        case "resource":
+            return {
+                primary: ["dto", "repository", "service", "controller", "routes", "test"],
+                required: [],
+                register: true,
+            };
+        case "route":
+            return {
+                primary: ["routes"],
+                required: ["dto", "repository", "service", "controller"],
+                register: true,
+            };
+        case "controller":
+            return { primary: ["controller"], required: ["dto", "repository", "service"], register: false };
+        case "repository":
+            return { primary: ["repository"], required: ["dto"], register: false };
+        case "dto":
+            return { primary: ["dto"], required: [], register: false };
+    }
+}
+//# sourceMappingURL=resource.plan.js.map

package/dist/src/generators/resource/resource.run.d.ts

@@ -0,0 +1,25 @@
+/**
+ * zudojs-cli — Running a resource-family schematic for `zudojs generate`.
+ */
+import type { CLIContext } from "../../cliType/cliType.type.js";
+import type { ResourceSchematic } from "./resource.plan.js";
+/** Inputs of {@link runResourceSchematic}. */
+export interface ResourceSchematicRun {
+    readonly schematic: ResourceSchematic;
+    readonly name: string;
+    readonly cwd: string;
+    /** `""` or `"apps/api"` (fullstack). */
+    readonly backendRoot: string;
+    readonly architecture: string | undefined;
+    readonly service?: string;
+    readonly moduleName?: string;
+    readonly dryRun: boolean;
+    readonly force: boolean;
+}
+/**
+ * Runs a resource-family schematic: writes the DTO → repository → service
+ * → controller → routes chain it needs and registers the routes and the
+ * controller between the project's markers.
+ */
+export declare function runResourceSchematic(context: CLIContext, run: ResourceSchematicRun): Promise<void>;
+//# sourceMappingURL=resource.run.d.ts.map

package/dist/src/generators/resource/resource.run.js

@@ -0,0 +1,52 @@
+/**
+ * zudojs-cli — Running a resource-family schematic for `zudojs generate`.
+ */
+import { describeError } from "../../commands/commandError.helper.js";
+import { CLIGenerationError, CLIValidationError } from "../../errors/index.js";
+import { generateResource } from "./resource.generator.js";
+import { resolveResourceLayout } from "./resource.layout.js";
+import { describeAddedDependencies, ensureZudojsDependencies, fileCount, } from "../../wiring/index.js";
+/**
+ * Runs a resource-family schematic: writes the DTO → repository → service
+ * → controller → routes chain it needs and registers the routes and the
+ * controller between the project's markers.
+ */
+export async function runResourceSchematic(context, run) {
+    const layout = resolveResourceLayout({
+        cwd: run.cwd,
+        architecture: run.architecture,
+        backendRoot: run.backendRoot,
+        ...(run.service !== undefined ? { service: run.service } : {}),
+        ...(run.moduleName !== undefined ? { module: run.moduleName } : {}),
+    });
+    let result;
+    try {
+        result = await generateResource({
+            name: run.name,
+            schematic: run.schematic,
+            layout,
+            dryRun: run.dryRun,
+            force: run.force,
+        }, run.cwd);
+    }
+    catch (error) {
+        if (error instanceof CLIValidationError)
+            throw error;
+        throw new CLIGenerationError(`Failed to generate ${run.schematic} "${run.name}": ${describeError(error)}`, error);
+    }
+    context.logger.info(run.dryRun
+        ? `Dry run: ${fileCount(result.files.length)} would be written or updated (nothing written):`
+        : `Generated ${fileCount(result.files.length)}:`);
+    for (const file of result.files) {
+        context.logger.info(`  - ${file}`);
+    }
+    if (!run.dryRun) {
+        for (const line of describeAddedDependencies(ensureZudojsDependencies(run.cwd, result.files))) {
+            context.logger.warn(line);
+        }
+    }
+    if (result.manualSteps.length > 0) {
+        context.logger.warn(`Finish by hand:\n${result.manualSteps.map((step) => `  - ${step}`).join("\n")}`);
+    }
+}
+//# sourceMappingURL=resource.run.js.map

package/dist/src/prompts/cancel.prompt.d.ts

@@ -11,8 +11,12 @@
  * an abort was indistinguishable from a success. The exit status is now 130,
  * the conventional "terminated by SIGINT" value.
  *
+ * The return type strips `symbol` from the argument's type rather than
+ * inferring `T` from `T | symbol`: TypeScript 7 infers the clack cancel
+ * symbol into `T` from that pattern, which broke every call site.
+ *
  * @param value - The value a `@clack/prompts` call resolved with.
  * @returns The answer, once it is known not to be the cancel symbol.
  */
-export declare function cancelled<T>(value: T | symbol): T;
+export declare function cancelled<T>(value: T): Exclude<T, symbol>;
 //# sourceMappingURL=cancel.prompt.d.ts.map

package/dist/src/prompts/cancel.prompt.js

@@ -13,6 +13,10 @@ import { CLI_EXIT_CODES } from "../cliConstant/cliConstant.value.js";
  * an abort was indistinguishable from a success. The exit status is now 130,
  * the conventional "terminated by SIGINT" value.
  *
+ * The return type strips `symbol` from the argument's type rather than
+ * inferring `T` from `T | symbol`: TypeScript 7 infers the clack cancel
+ * symbol into `T` from that pattern, which broke every call site.
+ *
  * @param value - The value a `@clack/prompts` call resolved with.
  * @returns The answer, once it is known not to be the cancel symbol.
  */

package/dist/src/prompts/menu/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * zudojs-cli — Interactive Menu
+ *
+ * The numbered menu a bare `zudojs` / `zudo` opens on an interactive
+ * terminal: entries, the digit-or-arrow select prompt, the flow that turns
+ * a choice into a command line, and the terminal prompter.
+ */
+export { MENU_CANCEL, type MenuCancel, type MenuFlowOptions, type MenuItem, type MenuItemId, type MenuOutcome, type MenuProjectScope, type MenuPrompter, } from "./menu.type.js";
+export { MENU_CANCELLED, MENU_ITEMS, MENU_MESSAGE, MENU_NAME_PATTERN, } from "./menu.constant.js";
+export { numberedSelect, type NumberedSelectIO } from "./menu.select.js";
+export { notInProjectMessage, runMenuFlow } from "./menu.flow.js";
+export { createTerminalMenuPrompter } from "./menu.adapter.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/prompts/menu/index.js

@@ -0,0 +1,13 @@
+/**
+ * zudojs-cli — Interactive Menu
+ *
+ * The numbered menu a bare `zudojs` / `zudo` opens on an interactive
+ * terminal: entries, the digit-or-arrow select prompt, the flow that turns
+ * a choice into a command line, and the terminal prompter.
+ */
+export { MENU_CANCEL, } from "./menu.type.js";
+export { MENU_CANCELLED, MENU_ITEMS, MENU_MESSAGE, MENU_NAME_PATTERN, } from "./menu.constant.js";
+export { numberedSelect } from "./menu.select.js";
+export { notInProjectMessage, runMenuFlow } from "./menu.flow.js";
+export { createTerminalMenuPrompter } from "./menu.adapter.js";
+//# sourceMappingURL=index.js.map

package/dist/src/prompts/menu/menu.adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * zudojs-cli — Menu Prompter
+ *
+ * The terminal implementation of `MenuPrompter`: the numbered select for
+ * the menu itself and `@clack/prompts` for the follow-up questions.
+ */
+import { type NumberedSelectIO } from "./menu.select.js";
+import { type MenuPrompter } from "./menu.type.js";
+/**
+ * Creates the prompter the binary uses.
+ *
+ * @param io - Streams to read keys from and draw on; defaults to the
+ *   process's stdin and stdout.
+ */
+export declare function createTerminalMenuPrompter(io?: NumberedSelectIO): MenuPrompter;
+//# sourceMappingURL=menu.adapter.d.ts.map

package/dist/src/prompts/menu/menu.adapter.js

@@ -0,0 +1,56 @@
+/**
+ * zudojs-cli — Menu Prompter
+ *
+ * The terminal implementation of `MenuPrompter`: the numbered select for
+ * the menu itself and `@clack/prompts` for the follow-up questions.
+ */
+import * as p from "@clack/prompts";
+import { numberedSelect } from "./menu.select.js";
+import { MENU_CANCEL, } from "./menu.type.js";
+/**
+ * Maps clack's cancel symbol onto the menu's own sentinel.
+ *
+ * Both follow-up prompts answer with a string, so anything else is the
+ * cancel symbol; narrowing on `string` avoids TypeScript 7 inferring the
+ * clack symbol into a generic parameter (see `cancelled`).
+ */
+function orCancel(value) {
+    return typeof value === "string" && !p.isCancel(value) ? value : MENU_CANCEL;
+}
+/**
+ * Creates the prompter the binary uses.
+ *
+ * @param io - Streams to read keys from and draw on; defaults to the
+ *   process's stdin and stdout.
+ */
+export function createTerminalMenuPrompter(io = { input: process.stdin, output: process.stdout }) {
+    return {
+        choose: (items) => numberedSelect(items, io),
+        async select(message, choices) {
+            const value = await p.select({
+                message,
+                options: choices.map((choice) => ({
+                    value: choice.value,
+                    label: choice.label,
+                    ...(choice.hint ? { hint: choice.hint } : {}),
+                })),
+            });
+            return orCancel(value);
+        },
+        async text(message, placeholder, validate) {
+            const value = await p.text({
+                message,
+                placeholder,
+                validate: (input) => validate(input ?? ""),
+            });
+            return orCancel(value);
+        },
+        warn(message) {
+            p.log.warn(message);
+        },
+        cancel(message) {
+            p.cancel(message);
+        },
+    };
+}
+//# sourceMappingURL=menu.adapter.js.map

package/dist/src/prompts/menu/menu.constant.d.ts

@@ -0,0 +1,20 @@
+/**
+ * zudojs-cli — Menu Entries
+ *
+ * The numbered entries of the interactive menu, in display order.
+ */
+import type { MenuItem } from "./menu.type.js";
+/** Menu entries; `key` is the digit that selects each one. */
+export declare const MENU_ITEMS: readonly MenuItem[];
+/** The question the menu asks. */
+export declare const MENU_MESSAGE = "What would you like to do?";
+/** Printed when the menu is left with Esc or Ctrl+C. */
+export declare const MENU_CANCELLED = "Operation cancelled.";
+/**
+ * Names accepted by the "Generate code" follow-up.
+ *
+ * The same shape the project-name prompt allows: a leading "-" would be
+ * parsed as an option once the name is handed to `generate`.
+ */
+export declare const MENU_NAME_PATTERN: RegExp;
+//# sourceMappingURL=menu.constant.d.ts.map