zudojs-cli 2.0.0 → 2.1.0

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

@@ -0,0 +1,29 @@
+/**
+ * zudojs-cli — Menu Entries
+ *
+ * The numbered entries of the interactive menu, in display order.
+ */
+/** Menu entries; `key` is the digit that selects each one. */
+export const MENU_ITEMS = Object.freeze([
+    { id: "create", key: "1", label: "Create a new project" },
+    { id: "dev", key: "2", label: "Start dev server", project: "cwd" },
+    { id: "generate", key: "3", label: "Generate code", project: "ancestor" },
+    { id: "add", key: "4", label: "Add a feature", project: "cwd" },
+    { id: "build", key: "5", label: "Build", project: "ancestor" },
+    { id: "doctor", key: "6", label: "Doctor", hint: "check the project" },
+    { id: "info", key: "7", label: "Info", hint: "CLI and project details" },
+    { id: "help", key: "8", label: "Help", hint: "list every command" },
+    { id: "exit", key: "0", label: "Exit" },
+]);
+/** The question the menu asks. */
+export const MENU_MESSAGE = "What would you like to do?";
+/** Printed when the menu is left with Esc or Ctrl+C. */
+export 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 const MENU_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+//# sourceMappingURL=menu.constant.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * zudojs-cli — Menu Flow
+ *
+ * Turns a menu choice into the argument list of an existing command,
+ * prompting for whatever that command requires.
+ */
+import { type MenuFlowOptions, type MenuItem, type MenuOutcome } from "./menu.type.js";
+/** Explains why a project-only entry cannot run in `cwd`. */
+export declare function notInProjectMessage(item: MenuItem, cwd: string, name: string): string;
+/**
+ * Runs the interactive menu until the user picks something runnable,
+ * exits, or cancels.
+ *
+ * A project-only entry chosen outside a project says so and shows the
+ * menu again rather than failing after its follow-up questions.
+ */
+export declare function runMenuFlow(options: MenuFlowOptions): Promise<MenuOutcome>;
+//# sourceMappingURL=menu.flow.d.ts.map

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

@@ -0,0 +1,82 @@
+/**
+ * zudojs-cli — Menu Flow
+ *
+ * Turns a menu choice into the argument list of an existing command,
+ * prompting for whatever that command requires.
+ */
+import { MENU_CANCELLED, MENU_ITEMS, MENU_NAME_PATTERN } from "./menu.constant.js";
+import { MENU_CANCEL, } from "./menu.type.js";
+/** Explains why a project-only entry cannot run in `cwd`. */
+export function notInProjectMessage(item, cwd, name) {
+    return (`"${item.label}" needs a Zudojs project, and ${cwd} is not inside one ` +
+        "(no .zudojs/manifest.json, zudojs.config.ts or zudojs block in package.json). " +
+        `Choose 1 to create a project, or cd into one and run "${name}" again.`);
+}
+/** Validates the resource name asked for by "Generate code". */
+function validateResourceName(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return "A name is required.";
+    if (!MENU_NAME_PATTERN.test(trimmed)) {
+        return "Must start with a letter or digit; only letters, digits, hyphens and underscores are allowed.";
+    }
+    return undefined;
+}
+/** Collects the arguments a chosen entry's command requires. */
+async function argumentsFor(item, options) {
+    const { prompter } = options;
+    switch (item.id) {
+        case "generate": {
+            const schematic = await prompter.select("What do you want to generate?", options.schematics);
+            if (schematic === MENU_CANCEL)
+                return MENU_CANCEL;
+            const name = await prompter.text(`Name of the ${schematic}?`, "user", validateResourceName);
+            if (name === MENU_CANCEL)
+                return MENU_CANCEL;
+            return ["generate", schematic, name.trim()];
+        }
+        case "add": {
+            const feature = await prompter.select("Which feature do you want to add?", options.features);
+            if (feature === MENU_CANCEL)
+                return MENU_CANCEL;
+            return ["add", feature];
+        }
+        case "help":
+            return ["--help"];
+        default:
+            // `create` prompts for its own name and options when run on a TTY;
+            // dev, build, doctor and info take no required arguments.
+            return [item.id];
+    }
+}
+/**
+ * Runs the interactive menu until the user picks something runnable,
+ * exits, or cancels.
+ *
+ * A project-only entry chosen outside a project says so and shows the
+ * menu again rather than failing after its follow-up questions.
+ */
+export async function runMenuFlow(options) {
+    const { prompter } = options;
+    for (;;) {
+        const id = await prompter.choose(MENU_ITEMS);
+        if (id === MENU_CANCEL) {
+            prompter.cancel(MENU_CANCELLED);
+            return { kind: "cancel" };
+        }
+        const item = MENU_ITEMS.find((entry) => entry.id === id);
+        if (!item || item.id === "exit")
+            return { kind: "exit" };
+        if (item.project && !options.isProject(options.cwd, item.project)) {
+            prompter.warn(notInProjectMessage(item, options.cwd, options.name));
+            continue;
+        }
+        const args = await argumentsFor(item, options);
+        if (args === MENU_CANCEL) {
+            prompter.cancel(MENU_CANCELLED);
+            return { kind: "cancel" };
+        }
+        return { kind: "run", args };
+    }
+}
+//# sourceMappingURL=menu.flow.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * zudojs-cli — Numbered Select
+ *
+ * A select prompt that takes either a digit or the arrow keys.
+ *
+ * `@clack/prompts`' `select` has no hook for "press 3 to pick the third
+ * entry", so this drives the keypress stream itself, with clack's glyphs and
+ * readline setup so it hands the terminal cleanly to the prompts after it.
+ */
+import { type MenuCancel, type MenuItem, type MenuItemId } from "./menu.type.js";
+/** The streams the prompt reads keys from and draws on. */
+export interface NumberedSelectIO {
+    readonly input: NodeJS.ReadableStream & {
+        readonly isTTY?: boolean;
+        setRawMode?(mode: boolean): unknown;
+    };
+    readonly output: NodeJS.WritableStream;
+}
+/**
+ * Shows the numbered menu and resolves with the chosen entry's id, or
+ * `MENU_CANCEL` on Esc / Ctrl+C.
+ *
+ * A digit picks its entry at once; ↑/↓ (or k/j) move and Enter confirms.
+ */
+export declare function numberedSelect(items: readonly MenuItem[], io: NumberedSelectIO): Promise<MenuItemId | MenuCancel>;
+//# sourceMappingURL=menu.select.d.ts.map

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

@@ -0,0 +1,118 @@
+/**
+ * zudojs-cli — Numbered Select
+ *
+ * A select prompt that takes either a digit or the arrow keys.
+ *
+ * `@clack/prompts`' `select` has no hook for "press 3 to pick the third
+ * entry", so this drives the keypress stream itself, with clack's glyphs and
+ * readline setup so it hands the terminal cleanly to the prompts after it.
+ */
+import * as readline from "node:readline";
+import { styleText } from "node:util";
+import * as p from "@clack/prompts";
+import { MENU_MESSAGE } from "./menu.constant.js";
+import { MENU_CANCEL, } from "./menu.type.js";
+const HIDE_CURSOR = "\u001B[?25l";
+const SHOW_CURSOR = "\u001B[?25h";
+/** Renders the frame for the current cursor position or final state. */
+function renderFrame(items, cursor, state, paint) {
+    const bar = paint("gray", p.S_BAR);
+    const current = items[cursor];
+    if (state !== "active") {
+        const submitted = state === "submit";
+        const symbol = submitted
+            ? paint("green", p.S_STEP_SUBMIT)
+            : paint("red", p.S_STEP_CANCEL);
+        const label = `${current.key}. ${current.label}`;
+        return [
+            bar,
+            `${symbol}  ${MENU_MESSAGE}`,
+            `${bar}  ${paint(submitted ? "dim" : ["strikethrough", "dim"], label)}`,
+        ];
+    }
+    const digits = items.map((item) => Number(item.key)).filter(Number.isFinite);
+    const keys = `${Math.min(...digits)}-${Math.max(...digits)}`;
+    return [
+        bar,
+        `${paint("cyan", p.S_STEP_ACTIVE)}  ${MENU_MESSAGE}`,
+        ...items.map((item, index) => {
+            const active = index === cursor;
+            const radio = active
+                ? paint("green", p.S_RADIO_ACTIVE)
+                : paint("dim", p.S_RADIO_INACTIVE);
+            const text = `${item.key}. ${item.label}`;
+            const hint = active && item.hint ? paint("dim", ` (${item.hint})`) : "";
+            return `${paint("cyan", p.S_BAR)}  ${radio} ${active ? text : paint("dim", text)}${hint}`;
+        }),
+        `${paint("cyan", p.S_BAR_END)}  ${paint("dim", `↑/↓ move · ${keys} pick · Enter select · Esc exit`)}`,
+    ];
+}
+/**
+ * Shows the numbered menu and resolves with the chosen entry's id, or
+ * `MENU_CANCEL` on Esc / Ctrl+C.
+ *
+ * A digit picks its entry at once; ↑/↓ (or k/j) move and Enter confirms.
+ */
+export function numberedSelect(items, io) {
+    const { input, output } = io;
+    const paint = (style, text) => styleText(style, text, { stream: output });
+    return new Promise((resolve) => {
+        let cursor = 0;
+        let drawn = 0;
+        const rl = readline.createInterface({
+            input,
+            tabSize: 2,
+            prompt: "",
+            escapeCodeTimeout: 50,
+            terminal: true,
+        });
+        readline.emitKeypressEvents(input, rl);
+        const draw = (state) => {
+            if (drawn > 0) {
+                readline.moveCursor(output, 0, -(drawn - 1));
+                readline.cursorTo(output, 0);
+                readline.clearScreenDown(output);
+            }
+            const lines = renderFrame(items, cursor, state, paint);
+            output.write(lines.join("\n"));
+            drawn = lines.length;
+        };
+        const finish = (result) => {
+            input.removeListener("keypress", onKeypress);
+            draw(result === MENU_CANCEL ? "cancel" : "submit");
+            output.write(`\n${SHOW_CURSOR}`);
+            if (input.isTTY)
+                input.setRawMode?.(false);
+            rl.close();
+            resolve(result);
+        };
+        const onKeypress = (text, key = {}) => {
+            if ((key.ctrl && key.name === "c") || key.name === "escape") {
+                return finish(MENU_CANCEL);
+            }
+            if (key.name === "return" || key.name === "enter") {
+                return finish(items[cursor].id);
+            }
+            if (key.name === "up" || key.name === "k") {
+                cursor = (cursor - 1 + items.length) % items.length;
+            }
+            else if (key.name === "down" || key.name === "j") {
+                cursor = (cursor + 1) % items.length;
+            }
+            else {
+                const index = items.findIndex((item) => item.key === text);
+                if (index < 0)
+                    return;
+                cursor = index;
+                return finish(items[index].id);
+            }
+            draw("active");
+        };
+        input.on("keypress", onKeypress);
+        if (input.isTTY)
+            input.setRawMode?.(true);
+        output.write(HIDE_CURSOR);
+        draw("active");
+    });
+}
+//# sourceMappingURL=menu.select.js.map

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

@@ -0,0 +1,66 @@
+/**
+ * zudojs-cli — Menu Types
+ *
+ * Contracts for the interactive menu shown by a bare `zudojs` / `zudo`.
+ */
+import type { CLIChoiceOption } from "../../constants/index.js";
+/** Returned by a prompt when the user pressed Esc or Ctrl+C. */
+export declare const MENU_CANCEL: unique symbol;
+/** The cancel sentinel's type. */
+export type MenuCancel = typeof MENU_CANCEL;
+/** Identifier of one menu entry. */
+export type MenuItemId = "create" | "dev" | "generate" | "add" | "build" | "doctor" | "info" | "help" | "exit";
+/**
+ * How an entry checks that it is inside a project.
+ *
+ * `cwd` mirrors `dev` and `add`, which only look at the current directory;
+ * `ancestor` mirrors `build` and `generate`, which walk up to the root.
+ */
+export type MenuProjectScope = "cwd" | "ancestor";
+/** One numbered entry of the menu. */
+export interface MenuItem {
+    readonly id: MenuItemId;
+    /** The digit that selects the entry. */
+    readonly key: string;
+    readonly label: string;
+    readonly hint?: string;
+    /** Set on entries that only work inside a Zudojs project. */
+    readonly project?: MenuProjectScope;
+}
+/**
+ * The prompts the menu needs, injectable so the flow can be tested
+ * without a terminal.
+ */
+export interface MenuPrompter {
+    /** Shows the numbered menu and resolves with the chosen entry. */
+    choose(items: readonly MenuItem[]): Promise<MenuItemId | MenuCancel>;
+    /** Asks the user to pick one of several values. */
+    select(message: string, choices: readonly CLIChoiceOption[]): Promise<string | MenuCancel>;
+    /** Asks for free text; `validate` returns an error message or nothing. */
+    text(message: string, placeholder: string, validate: (value: string) => string | undefined): Promise<string | MenuCancel>;
+    /** Tells the user an entry cannot run here. */
+    warn(message: string): void;
+    /** Reports that the menu was cancelled. */
+    cancel(message: string): void;
+}
+/** What the menu decided. */
+export type MenuOutcome = {
+    readonly kind: "run";
+    readonly args: readonly string[];
+} | {
+    readonly kind: "exit";
+} | {
+    readonly kind: "cancel";
+};
+/** Dependencies of the menu flow. */
+export interface MenuFlowOptions {
+    readonly prompter: MenuPrompter;
+    readonly cwd: string;
+    /** The name the user typed, for messages (`zudo` or `zudojs`). */
+    readonly name: string;
+    /** Whether `cwd` is inside a Zudojs project for the given scope. */
+    readonly isProject: (cwd: string, scope: MenuProjectScope) => boolean;
+    readonly schematics: readonly CLIChoiceOption[];
+    readonly features: readonly CLIChoiceOption[];
+}
+//# sourceMappingURL=menu.type.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * zudojs-cli — Menu Types
+ *
+ * Contracts for the interactive menu shown by a bare `zudojs` / `zudo`.
+ */
+/** Returned by a prompt when the user pressed Esc or Ctrl+C. */
+export const MENU_CANCEL = Symbol("zudojs.menu.cancel");
+//# sourceMappingURL=menu.type.js.map

package/dist/src/recipes/apply/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Applying recipes to a project on disk.
+ */
+export * from "./recipeApply.app.js";
+export * from "./recipeApply.files.js";
+export * from "./recipeApply.project.js";
+export * from "./recipeApply.context.js";
+export * from "./recipeApply.report.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/recipes/apply/index.js

@@ -0,0 +1,9 @@
+/**
+ * zudojs-cli — Applying recipes to a project on disk.
+ */
+export * from "./recipeApply.app.js";
+export * from "./recipeApply.files.js";
+export * from "./recipeApply.project.js";
+export * from "./recipeApply.context.js";
+export * from "./recipeApply.report.js";
+//# sourceMappingURL=index.js.map

package/dist/src/recipes/apply/recipeApply.app.d.ts

@@ -0,0 +1,20 @@
+/**
+ * zudojs-cli — Applying an app recipe to one backend app.
+ *
+ * Writes the integration file and the recipe's extra files when they are
+ * missing, registers the integration, config section and server lines
+ * between their markers, and merges `.env.example` and `package.json`.
+ * Files that exist are kept, never overwritten; a missing marker becomes a
+ * manual step instead of an edit.
+ */
+import type { AppRecipe, RecipeContext } from "../recipe.type.js";
+/** What applying a recipe to one app did. */
+export interface RecipeOutcome {
+    readonly written: readonly string[];
+    readonly kept: readonly string[];
+    readonly edited: readonly string[];
+    readonly manualSteps: readonly string[];
+}
+/** Applies `recipe` to the app at `context.appRoot` of the project at `root`. */
+export declare function applyAppRecipe(recipe: AppRecipe, context: RecipeContext, root: string): Promise<RecipeOutcome>;
+//# sourceMappingURL=recipeApply.app.d.ts.map

package/dist/src/recipes/apply/recipeApply.app.js

@@ -0,0 +1,79 @@
+/**
+ * zudojs-cli — Applying an app recipe to one backend app.
+ *
+ * Writes the integration file and the recipe's extra files when they are
+ * missing, registers the integration, config section and server lines
+ * between their markers, and merges `.env.example` and `package.json`.
+ * Files that exist are kept, never overwritten; a missing marker becomes a
+ * manual step instead of an edit.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFile } from "../../utils/utils.fileSystem.js";
+import { MARKERS, applyMarkerEdits } from "../../wiring/index.js";
+import { mergePackageJson, withEnvVariables } from "./recipeApply.files.js";
+/** Joins a root-relative app dir and a path inside it. */
+function inApp(appRoot, path) {
+    return appRoot === "" ? path : `${appRoot}/${path}`;
+}
+/** Applies `recipe` to the app at `context.appRoot` of the project at `root`. */
+export async function applyAppRecipe(recipe, context, root) {
+    recipe.validate?.(context);
+    const at = (path) => inApp(context.appRoot, path);
+    const written = [];
+    const kept = [];
+    const edits = [];
+    const files = { ...(recipe.files?.(context) ?? {}) };
+    if (recipe.integration !== undefined) {
+        const { file, exportName } = recipe.integration;
+        files[`src/integrations/${file}`] = recipe.integration.source(context);
+        const index = at("src/integrations/index.ts");
+        const module = file.replace(/\.ts$/, ".js");
+        edits.push({ file: index, marker: MARKERS.integrationImports, line: `import { ${exportName} } from "./${module}";` }, { file: index, marker: MARKERS.integrations, line: `${exportName},` });
+    }
+    for (const [path, content] of Object.entries(files)) {
+        if (existsSync(join(root, at(path)))) {
+            kept.push(at(path));
+        }
+        else {
+            await writeFile(root, at(path), content);
+            written.push(at(path));
+        }
+    }
+    if (recipe.configSection !== undefined) {
+        edits.push({ file: at("src/configs/index.ts"), marker: MARKERS.config, line: recipe.configSection });
+    }
+    for (const { marker, line } of recipe.serverLines?.(context) ?? []) {
+        edits.push({ file: at("src/server.ts"), marker, line });
+    }
+    const configFile = join(root, at("src/configs/index.ts"));
+    const configKey = recipe.configSection?.split(":")[0];
+    const configured = configKey !== undefined &&
+        existsSync(configFile) &&
+        new RegExp(`^\\s*${configKey}:`, "m").test(readFileSync(configFile, "utf-8"));
+    const outcome = await applyMarkerEdits(root, configured ? edits.filter((edit) => edit.marker !== MARKERS.config) : edits);
+    const edited = [...outcome.edited];
+    const envPath = at(".env.example");
+    const env = recipe.env?.(context) ?? [];
+    if (env.length > 0) {
+        const current = existsSync(join(root, envPath)) ? readFileSync(join(root, envPath), "utf-8") : "";
+        const next = withEnvVariables(current, env);
+        if (next !== undefined) {
+            await writeFile(root, envPath, next);
+            edited.push(envPath);
+        }
+    }
+    const pkgPath = at("package.json");
+    const pkg = JSON.parse(readFileSync(join(root, pkgPath), "utf-8"));
+    mergePackageJson(pkg, {
+        feature: recipe.feature,
+        dependencies: recipe.dependencies,
+        ...(recipe.devDependencies ? { devDependencies: recipe.devDependencies } : {}),
+        ...(recipe.scripts ? { scripts: recipe.scripts } : {}),
+        ...(recipe.replaceScripts ? { replaceScripts: recipe.replaceScripts } : {}),
+    });
+    await writeFile(root, pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    edited.push(pkgPath);
+    return { written, kept, edited, manualSteps: outcome.manualSteps };
+}
+//# sourceMappingURL=recipeApply.app.js.map

package/dist/src/recipes/apply/recipeApply.context.d.ts

@@ -0,0 +1,14 @@
+/**
+ * zudojs-cli — What recipes need to know about a project on disk.
+ */
+import type { ProjectLayout } from "../../resolvers/layout/projectLayout.core.js";
+import type { ProjectRecipeContext, RecipeContext } from "../recipe.type.js";
+/** The project name as a slug (from the root package.json). */
+export declare function projectSlug(root: string): string;
+/** The database engine recorded in `.zudojs/manifest.json` (default postgresql). */
+export declare function recordedDatabase(root: string): string;
+/** The recipe context of one backend app. */
+export declare function recipeContextFor(root: string, dir: string): RecipeContext;
+/** The context of a project recipe (docker) for `layout`. */
+export declare function projectRecipeContext(layout: ProjectLayout, feature: string, capabilities: readonly string[]): ProjectRecipeContext;
+//# sourceMappingURL=recipeApply.context.d.ts.map

package/dist/src/recipes/apply/recipeApply.context.js

@@ -0,0 +1,76 @@
+/**
+ * zudojs-cli — What recipes need to know about a project on disk.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+function readJson(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** The project name as a slug (from the root package.json). */
+export function projectSlug(root) {
+    const name = readJson(join(root, "package.json"))["name"];
+    const raw = typeof name === "string" && name !== "" ? name : basename(root);
+    return raw.replace(/^@[^/]+\//, "").replace(/[^a-z0-9-]+/gi, "-").toLowerCase() || "app";
+}
+/** The database engine recorded in `.zudojs/manifest.json` (default postgresql). */
+export function recordedDatabase(root) {
+    const database = readJson(join(root, ".zudojs", "manifest.json"))["database"];
+    return typeof database?.provider === "string" ? database.provider : "postgresql";
+}
+/** The app's name: `app` for the project root, else its directory name. */
+function appName(root, dir) {
+    return dir === root ? "app" : basename(dir);
+}
+/** The recipe context of one backend app. */
+export function recipeContextFor(root, dir) {
+    return {
+        projectSlug: projectSlug(root),
+        appName: appName(root, dir),
+        database: recordedDatabase(root),
+        appRoot: relative(root, dir).split("\\").join("/"),
+    };
+}
+/** PORT from an app's `.env.example`, else `fallback`. */
+function recordedPort(dir, fallback) {
+    const path = join(dir, ".env.example");
+    const match = existsSync(path) ? /^PORT=(\d+)\s*$/m.exec(readFileSync(path, "utf-8")) : null;
+    const port = Number(match?.[1]);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : fallback;
+}
+/** Features declared in an app's package.json. */
+function declaredFeatures(dir) {
+    const block = readJson(join(dir, "package.json"))["zudojs"];
+    return Array.isArray(block?.features)
+        ? block.features.filter((f) => typeof f === "string")
+        : [];
+}
+/** The context of a project recipe (docker) for `layout`. */
+export function projectRecipeContext(layout, feature, capabilities) {
+    const apps = layout.backendDirs.map((dir, index) => ({
+        dir: relative(layout.root, dir).split("\\").join("/"),
+        name: appName(layout.root, dir),
+        port: recordedPort(dir, 3000 + index),
+        prisma: existsSync(join(dir, "prisma", "schema.prisma")),
+    }));
+    const features = new Set([feature, ...capabilities]);
+    for (const dir of layout.backendDirs) {
+        for (const declared of declaredFeatures(dir))
+            features.add(declared);
+    }
+    return {
+        root: layout.root,
+        projectSlug: projectSlug(layout.root),
+        architecture: layout.architecture,
+        packageManager: layout.packageManager,
+        database: recordedDatabase(layout.root),
+        features,
+        apps,
+    };
+}
+//# sourceMappingURL=recipeApply.context.js.map

package/dist/src/recipes/apply/recipeApply.files.d.ts

@@ -0,0 +1,39 @@
+/**
+ * zudojs-cli — Edits `add` makes to plain project files: `.env.example`,
+ * `.gitignore`, `package.json` and `pnpm-workspace.yaml`. Every edit is
+ * additive and idempotent; existing values are never replaced (except the
+ * scripts a recipe names explicitly, and only from their generated value).
+ */
+import type { EnvVariable } from "../../templates/backendApp/index.js";
+/** `.env.example` with the variables it does not declare yet appended. */
+export declare function withEnvVariables(current: string, variables: readonly EnvVariable[]): string | undefined;
+/** `.gitignore` with the lines it lacks appended. */
+export declare function withGitignoreLines(current: string, lines: readonly string[]): string | undefined;
+/** A package.json shape `add` edits. */
+export interface EditablePackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+    zudojs?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** What to merge into a package.json. */
+export interface PackageJsonChanges {
+    readonly feature: string;
+    readonly dependencies: Readonly<Record<string, string>>;
+    readonly devDependencies?: Readonly<Record<string, string>>;
+    readonly scripts?: Readonly<Record<string, string>>;
+    readonly replaceScripts?: Readonly<Record<string, {
+        from: string;
+        to: string;
+    }>>;
+}
+/** Merges `changes` into `pkg` in place. */
+export declare function mergePackageJson(pkg: EditablePackageJson, changes: PackageJsonChanges): void;
+/**
+ * `pnpm-workspace.yaml` with `names` added to both build-script allow-lists
+ * (pnpm 10 `onlyBuiltDependencies`, pnpm 11 `allowBuilds`). Returns
+ * `undefined` when there is no such file or nothing to add.
+ */
+export declare function withAllowedBuilds(root: string, names: readonly string[]): string | undefined;
+//# sourceMappingURL=recipeApply.files.d.ts.map