@aventara/cli 0.1.0-pilot.4 → 1.0.0-rc.0

package/CHANGELOG.md

@@ -0,0 +1,114 @@
+# @aventara/cli
+
+## 1.0.0-rc.0
+
+### Major Changes
+
+- First release candidate of Aventara 1.0. The public API is now considered stable; changes before 1.0.0 are possible
+  based on feedback.
+
+### Minor Changes
+
+- 24ffbab: `aventara new`, `aventara init`, `avclient init` and `avclient generate` show their steps while they work, so a long
+  install never looks hung: on a terminal, `[3/4] Installing dependencies (npm install)` with a spinner and the seconds so
+  far, then `✓` or `✗` and its time; in a pipe, in CI or with `NO_COLOR`, one plain line per step (`… done (12.4s)`),
+  with no control sequence. A closing line gives the total time. The steps go to stderr; stdout keeps the results and the
+  next steps. The output of `nest new` and of the install is shown only when it fails, as before, or as it runs with the
+  new `--verbose`.
+
+### Patch Changes
+
+- 24ffbab: Each package ships its `CHANGELOG.md`, so the release notes are in the installed package beside the README.
+- 24ffbab: `aventara new` prints its next steps last — after the initial commit and the closing line — so they are what is on
+  screen when it ends, in a terminal and in a pipe alike.
+
+## 0.1.0-pilot.4
+
+### Patch Changes
+
+- f37dcd6: `@aventara/cli` ships no type declarations: it is a command, run with `npx` or installed globally, and has no API to
+  import.
+- f37dcd6: `aventara new` and `aventara init` add `prebuild`, `prestart`, `prestart:dev` and `prestart:debug` scripts that run
+  `aventara:prepare`, so after a change to `schema.prisma` the next `npm run start:dev` (or `build`, `start`,
+  `start:debug`) regenerates the Prisma client and the discovery artifact before the server compiles — no reinstall
+  needed. npm and pnpm both run these hooks. On an existing project, `aventara init` treats a `prebuild` or `prestart*`
+  script you already have as a conflict, like any other script: kept unless you confirm, replaced with `--yes`.
+
+  The scaffold's rate-limiting note in `src/main.ts` links to the docs:
+  `https://aventara-docs.vercel.app/docs/limits-and-safety#rate-limiting`.
+
+## 0.1.0-pilot.3
+
+### Patch Changes
+
+- d8c128b: `aventara new` and `aventara init` turn CORS on in `src/main.ts`, so a browser frontend on another port can call the
+  API — 0.1.0-pilot.2's scaffold had none, and a browser's preflight got the protocol's answer instead. Right after
+  `const app = await NestFactory.create(AppModule);` they add `app.enableCors({ origin: … })` with the comma-separated
+  origins in `CORS_ORIGINS`, and write `CORS_ORIGINS="http://localhost:5173,http://localhost:3001"` into the `.env` they
+  write. Unset or empty, CORS is **off** (`origin: false`), never open to every origin. A `main.ts` that already
+  configures CORS is left as it is, with a warning; one without that line is not edited, and the lines are printed. Over an
+  existing Prisma setup, whose `.env` init never writes, adding `CORS_ORIGINS` is printed as a next step. Nest's
+  `enableCors` reaches Aventara's routes on Express and Fastify alike: preflights naming the `Aventara-*` headers are
+  allowed, and the calls answered with the origin.
+- 05d39e8: `aventara new` ends with the project's first git commit, `Initial Aventara Scaffold`: every scaffolded file and the
+  install's lockfile, never `.env` (it is in `.gitignore`). 0.1.0-pilot.2 left a repository with nothing committed. Where
+  a commit cannot or should not be made the run still succeeds, saying why in one line: git is not installed, git has no
+  `user.name`/`user.email`, or the directory `new` ran in is already inside a git repository (a monorepo), where no
+  commit is made in either repository. `--skip-git` creates no repository and makes no commit; `aventara init` never
+  commits.
+- 6755a1f: `aventara --help`, `aventara new --help` and `aventara init --help` list the values `--orm`, `--db` and
+  `--package-manager` take, read from the adapter catalog: `--orm <prisma7>`, `--db <sqlite|postgresql>`,
+  `--package-manager <npm|pnpm>`. A refused `--orm` now names the values it takes — "`--orm takes prisma7 (Prisma 7,
+@aventara/prisma7-adapter)`" — where 0.1.0-pilot.2 said "available: Prisma 7", which is not a value the flag accepts.
+- 2afc651: The `main.ts` lines `aventara new` and `aventara init` add now end with a commented-out, platform-level rate limiter
+  and a short note on why: `@nestjs/throttler` is a Nest guard and does not run on Aventara's routes, while Express
+  middleware does. Uncommented (after `npm i express-rate-limit` and its import), it limits the protocol's routes and
+  answers `429` past the limit. Nothing is installed or enabled by default.
+- `CORS_ORIGINS="http://localhost:5173,http://localhost:3001"` is appended to the project's existing `.env` too — over an existing Prisma setup as well — every other line kept, and never when a line already sets `CORS_ORIGINS`; only a reused setup with no `.env` gets it as a printed next step.
+- `--orm` takes an adapter's alias, `prisma7` (Prisma 7, `@aventara/prisma7-adapter`), declared in the adapter's manifest and listed by `--help`; `prisma@7` and `prisma` are no longer accepted.
+
+## 0.1.0-pilot.2
+
+### Patch Changes
+
+- aa65a0c: `aventara new` and `aventara init` add `.env` to the project's `.gitignore` whenever they write the `DATABASE_URL`
+  entry into `.env`. The file is only appended to: existing lines are kept, and nothing is added when `.env` is already
+  listed.
+- e69e88d: The published packages are written for the people who use them. The JavaScript ships without comments; the type
+  declarations keep their documentation, and it, the error messages, the protocol fixtures' labels and the comments in a
+  generated client no longer carry the project's internal development notes.
+- 0ec37d4: `avclient --version` (and `-v`) prints the generator's version and exits 0, and `aventara` now accepts `-v` beside
+  `--version`, so both bins answer the same two flags.
+
+## 0.1.0-pilot.1
+
+### Patch Changes
+
+- 7714ef3: The scaffold's e2e test now proves Aventara is mounted. `aventara new` and `aventara init` add a `GET /api/_contract`
+  → 200 test to Nest's `test/app.e2e-spec.ts`, right after its `GET /` test (ESM and CommonJS), when AventaraModule was
+  added and the spec is Nest's own; a spec of the developer's own is left untouched.
+- 7f2b5d4: The frontend next step is now a command that runs as printed: `pnpm dlx` under pnpm (not `npx`), and, while the CLI is a
+  prerelease, the client's dist-tag read from the CLI's own version — `npx @aventara/client@pilot init` for
+  0.1.0-pilot.N — so a frontend gets the client from the same release instead of nothing (`@aventara/client` has no
+  `latest`).
+- 799346e: The package READMEs (each package's npm page) are rewritten for the people who use the packages. The Prisma 7
+  adapter's README now states the actual behaviour of a to-many relation or `$count` projected on
+  `update.many`/`create.many`: a validation refusal, `A2004` with `V1008`, before any statement runs (it said `A3001`).
+  Every install or run command names the `@pilot` dist-tag.
+- e58aebf: The READMEs show how to call the API by hand: a copy-pasteable `curl` that fetches `/api/_contract` and sends a
+  `find.many` with both identity headers, and runs as printed against a scaffolded server. They also say that
+  Resource keys are the model names as written (`/_resources/User/…`, `avClient.User.find.many`), and that list results are
+  `readonly` arrays (`readonly User[]`).
+- 88408be: `--help` (and `-h`) works after a command: `aventara new --help`, `aventara init --help`, `avclient init --help` and
+  `avclient generate --help` print that command's usage and exit 0, instead of refusing "unknown flag --help". Nothing
+  else on the line is read or run.
+
+## 0.1.0-pilot.0
+
+### Minor Changes
+
+- b65a4f8: New package: `@aventara/cli`, bin `aventara`. `aventara new <name>` runs the pinned `nest new` and adds Aventara;
+  `aventara init` adds Aventara to an existing NestJS 12 project — the Prisma 7 schema, config and service when there is
+  no ORM yet, or the developer's own Prisma setup reused and never written. Every question has a flag; `--yes` accepts the
+  defaults; a non-interactive run without the answers refuses before writing anything. The ORMs and databases on offer
+  come from the adapter packages' own manifests.

package/README.md

@@ -3,13 +3,13 @@
 The `aventara` command: it scaffolds an Aventara server on NestJS 12.
 
 ```bash
-npm i -g @aventara/cli@pilot  # or run it once: npx @aventara/cli@pilot <command>
+npm i -g @aventara/cli@rc  # or run it once: npx @aventara/cli@rc <command>
 aventara new my-api           # a new NestJS project with Aventara
 aventara init                 # Aventara added to the NestJS 12 project in this directory
 ```
 
 It is run once, globally or through `npx`; it is not a dependency of the projects it writes. The frontend's side —
-`framework.client.ts` and the generated client — is `@aventara/client`'s (`npx @aventara/client@pilot init`).
+`framework.client.ts` and the generated client — is `@aventara/client`'s (`npx @aventara/client@rc init`).
 
 ## `aventara new <name>`
 
@@ -51,6 +51,11 @@ possible answer is shown, not asked.
 | `--skip-install` | Write the files; print the install instead of running it. | |
 | `--skip-git` (`new`) | Passed to `nest new`. | |
 | `-y`, `--yes` | Accept every unanswered default **and** replace existing content that differs. | |
+| `--verbose` | Show the output of `nest new` and the install as they run. | |
+
+While it works, each step is shown on stderr — `[3/4] Installing dependencies (npm install)` — with a spinner and the
+seconds so far on a terminal, or as one plain line per step (`… done (12.4s)`) in a pipe, in CI (`CI`) or with
+`NO_COLOR`; the output of `nest new` and the install is shown only if it fails, or with `--verbose`.
 
 Existing content that differs from what would be written (a `.env` key, a script, a file) is listed, and replaced only
 when you confirm, or with `--yes`; where nobody can be asked, the run stops and touches nothing.
@@ -76,11 +81,11 @@ when you confirm, or with `--yes`; where nobody can be asked, the run stops and
 ```bash
 npx prisma db push          # create the tables (init never touches a database); pnpm: pnpm exec prisma db push
 npm run start:dev           # GET http://localhost:3000/api/_contract
-npx @aventara/client@pilot init   # in your frontend; pnpm: pnpm dlx @aventara/client@pilot init
+npx @aventara/client@rc init   # in your frontend; pnpm: pnpm dlx @aventara/client@rc init
 ```
 
 The frontend command is the package manager's own runner (`npx`, or `pnpm dlx` under pnpm) and, while the CLI is a
-prerelease, carries its dist-tag (`@pilot`), so the client comes from the same release.
+prerelease, carries its dist-tag (`@rc`), so the client comes from the same release.
 
 With PostgreSQL, set `DATABASE_URL` in `.env` first (init writes Prisma's placeholder, and never asks for a secret).
 

package/dist/cli.js

@@ -6,6 +6,7 @@ import { ProjectRefusedError } from "./project/project.inspector.js";
 import { runCommand } from "./run/command.runner.js";
 import { InstallFailedError, runInit } from "./run/init.orchestrator.js";
 import { runNew } from "./run/new.orchestrator.js";
+import { progressModeOf } from "./run/step.reporter.js";
 import { UnansweredQuestionsError, } from "./wizard/answer.resolver.js";
 import { createReadlinePrompter, WizardCancelledError, } from "./wizard/readline.prompter.js";
 import { WizardAnswerError } from "./wizard/wizard.questions.js";
@@ -47,6 +48,7 @@ export async function runCli(argv, io) {
                 runner: io.runner ?? runCommand,
                 catalog: io.catalog ?? ADAPTER_CATALOG,
                 aventaraVersion: ownVersion(),
+                progressMode: io.progress ?? "off",
             });
         }
         return await runNew(command, {
@@ -58,6 +60,7 @@ export async function runCli(argv, io) {
             runner: io.runner ?? runCommand,
             catalog: io.catalog ?? ADAPTER_CATALOG,
             aventaraVersion: ownVersion(),
+            progressMode: io.progress ?? "off",
         });
     }
     catch (error) {
@@ -85,6 +88,7 @@ export async function runFromProcess() {
                 process.stderr.write(text);
             },
             prompter,
+            progress: progressModeOf(process.stderr.isTTY, process.env),
         });
     }
     finally {

package/dist/command/command.parser.js

@@ -22,6 +22,12 @@ const OPTIONS = [
         commands: ["new", "init"],
         summary: "accept every unanswered question's default, and confirm overwriting existing content",
     },
+    {
+        flag: "--verbose",
+        key: "verbose",
+        commands: ["new", "init"],
+        summary: "show the output of every command it runs as it runs (nest new, the install)",
+    },
 ];
 const QUESTIONS = {
     new: NEW_QUESTIONS,
@@ -165,5 +171,6 @@ export function parseCliCommand(argv) {
         skipInstall: options.skipInstall === true,
         skipGit: options.skipGit === true,
         yes: options.yes === true,
+        ...(options.verbose === true ? { verbose: true } : {}),
     };
 }

package/dist/run/command.runner.js

@@ -9,9 +9,11 @@ export const runCommand = (command, args, options) => new Promise((resolve, reje
     let stderr = "";
     child.stdout.setEncoding("utf8").on("data", (chunk) => {
         stdout += chunk;
+        options.onOutput?.(chunk);
     });
     child.stderr.setEncoding("utf8").on("data", (chunk) => {
         stderr += chunk;
+        options.onOutput?.(chunk);
     });
     child.once("error", reject);
     child.once("close", (code) => {

package/dist/run/init.orchestrator.js

@@ -9,10 +9,20 @@ import { scanServices } from "../project/service.detector.js";
 import { templatesFor, } from "../templates/template.registry.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
 import { INIT_QUESTIONS, REUSE_QUESTIONS, } from "../wizard/wizard.questions.js";
+import { createStepReporter, } from "./step.reporter.js";
+export function printNextSteps(stdout, steps) {
+    stdout(`Next:\n${steps.map((step, index) => `  ${index + 1}. ${step}`).join("\n")}\n`);
+}
 export class InstallFailedError extends Error {
     name = "InstallFailedError";
 }
 export async function runInit(command, io) {
+    const { progress, nextSteps } = await initProject(command, io);
+    progress.finish("aventara", "done");
+    printNextSteps(io.stdout, nextSteps);
+    return 0;
+}
+export async function initProject(command, io) {
     const inspection = inspectProject(io.directory, io.catalog);
     const read = (file) => {
         try {
@@ -48,11 +58,20 @@ export async function runInit(command, io) {
         prompter: io.prompter,
     });
     const writes = plan.conflicts.length === 0 ? plan.keeping : plan.replacing;
-    for (const write of writes) {
-        const target = path.join(io.directory, write.path);
-        mkdirSync(path.dirname(target), { recursive: true });
-        writeFileSync(target, write.content);
-    }
+    const progress = io.progress ??
+        createStepReporter({
+            write: io.stderr,
+            mode: io.progressMode,
+            total: command.skipInstall ? 1 : 2,
+            verbose: command.verbose === true,
+        });
+    await progress.step("Writing Aventara's files", () => {
+        for (const write of writes) {
+            const target = path.join(io.directory, write.path);
+            mkdirSync(path.dirname(target), { recursive: true });
+            writeFileSync(target, write.content);
+        }
+    });
     for (const warning of plan.warnings) {
         io.stderr(`aventara: warning: ${warning}.\n`);
     }
@@ -63,16 +82,17 @@ export async function runInit(command, io) {
         io.stdout(`${plan.instructions}\n`);
     }
     if (!command.skipInstall) {
-        io.stdout(`aventara: running ${packageManager} install…\n`);
-        const installed = await io.runner(packageManager, ["install"], {
-            cwd: io.directory,
+        await progress.step(`Installing dependencies (${packageManager} install)`, async () => {
+            const installed = await io.runner(packageManager, ["install"], {
+                cwd: io.directory,
+                onOutput: progress.output,
+            });
+            if (installed.code !== 0) {
+                throw new InstallFailedError(`\`${packageManager} install\` exited with code ${installed.code} after the files were written; fix what it reports and run \`${packageManager} install\` again:\n${installed.stderr.trimEnd()}`);
+            }
         });
-        if (installed.code !== 0) {
-            throw new InstallFailedError(`\`${packageManager} install\` exited with code ${installed.code} after the files were written; fix what it reports and run \`${packageManager} install\` again:\n${installed.stderr.trimEnd()}`);
-        }
     }
-    io.stdout(`Next:\n${[...(io.firstSteps ?? []), ...plan.nextSteps].map((step, index) => `  ${index + 1}. ${step}`).join("\n")}\n`);
-    return 0;
+    return { progress, nextSteps: plan.nextSteps };
 }
 async function prepareFresh(command, io, inspection, detectedPackageManager) {
     const answers = await resolveAnswers(INIT_QUESTIONS, {

package/dist/run/new.orchestrator.js

@@ -5,8 +5,9 @@ import { detectPackageManager } from "../project/package-manager.detector.js";
 import { ProjectRefusedError } from "../project/project.inspector.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
 import { NEW_QUESTIONS } from "../wizard/wizard.questions.js";
-import { InstallFailedError, runInit, } from "./init.orchestrator.js";
+import { InstallFailedError, initProject, printNextSteps, } from "./init.orchestrator.js";
 import { commitScaffold, gitSurroundings } from "./scaffold.committer.js";
+import { createStepReporter } from "./step.reporter.js";
 export const NEST_CLI = "@nestjs/cli@12.0.8";
 export const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
 function oneOff(packageManager) {
@@ -50,11 +51,21 @@ export async function runNew(command, io) {
         "--no-observe",
         ...(command.skipGit ? ["--skip-git"] : []),
     ];
-    io.stdout(`aventara: running ${runner} ${args.join(" ")}…\n`);
-    const created = await io.runner(runner, args, { cwd: io.cwd });
-    if (created.code !== 0) {
-        throw new InstallFailedError(`\`${runner} ${args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again:\n${created.stderr.trimEnd()}`);
-    }
+    const progress = createStepReporter({
+        write: io.stderr,
+        mode: io.progressMode,
+        total: 2 + (command.skipInstall ? 0 : 1) + (command.skipGit ? 0 : 1),
+        verbose: command.verbose === true,
+    });
+    await progress.step(`Creating the NestJS project (${runner} ${[...prefix, NEST_CLI, "new", name].join(" ")})`, async () => {
+        const created = await io.runner(runner, args, {
+            cwd: io.cwd,
+            onOutput: progress.output,
+        });
+        if (created.code !== 0) {
+            throw new InstallFailedError(`\`${runner} ${args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again:\n${created.stderr.trimEnd()}`);
+        }
+    });
     const appModule = path.join(directory, "src", "app.module.ts");
     const digest = existsSync(appModule)
         ? createHash("sha256").update(readFileSync(appModule)).digest("hex")
@@ -62,7 +73,7 @@ export async function runNew(command, io) {
     if (digest !== NEST_APP_MODULE_SHA256) {
         throw new InstallFailedError(`nest new's output changed: ${appModule} is not what ${NEST_CLI} writes (sha256 ${digest}), so nothing of Aventara's was written over it; run aventara init inside ${directory} to add Aventara to it`);
     }
-    const initialized = await runInit({
+    const { nextSteps } = await initProject({
         command: "init",
         given: {
             orm: orm.alias,
@@ -72,9 +83,16 @@ export async function runNew(command, io) {
         skipInstall: command.skipInstall,
         skipGit: false,
         yes: true,
-    }, { ...io, directory, firstSteps: [`Enter the project: cd ${name}`] });
-    if (initialized === 0 && surroundings !== undefined) {
-        io.stdout(`aventara: ${await commitScaffold(io.runner, directory, surroundings, io.cwd)}.\n`);
+    }, {
+        ...io,
+        directory,
+        progress,
+    });
+    if (surroundings !== undefined) {
+        const committed = await progress.step("Committing the scaffold", () => commitScaffold(io.runner, directory, surroundings, io.cwd));
+        io.stdout(`aventara: ${committed}.\n`);
     }
-    return initialized;
+    progress.finish("aventara", `created ${name}`);
+    printNextSteps(io.stdout, [`Enter the project: cd ${name}`, ...nextSteps]);
+    return 0;
 }

package/dist/run/step.reporter.js

@@ -0,0 +1,87 @@
+export function progressModeOf(isTTY, env) {
+    const ci = env.CI;
+    if (isTTY !== true ||
+        (ci !== undefined && ci !== "" && ci !== "0" && ci !== "false") ||
+        (env.NO_COLOR !== undefined && env.NO_COLOR !== "") ||
+        env.TERM === "dumb") {
+        return "plain";
+    }
+    return "live";
+}
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CLEAR_LINE = "\r\u001b[2K";
+const GREEN = (text) => `\u001b[32m${text}\u001b[39m`;
+const RED = (text) => `\u001b[31m${text}\u001b[39m`;
+const DIM = (text) => `\u001b[2m${text}\u001b[22m`;
+export function formatElapsed(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    const whole = Math.round(seconds);
+    return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+}
+export function createStepReporter(options) {
+    const now = options.now ?? Date.now;
+    const started = now();
+    const verbose = options.verbose === true && options.mode !== "off";
+    const mode = verbose ? "plain" : options.mode;
+    let index = 0;
+    const step = async (title, body) => {
+        index += 1;
+        const label = `[${index}/${options.total}] ${title}`;
+        const at = now();
+        const elapsed = () => formatElapsed(now() - at);
+        if (mode === "off") {
+            return await body();
+        }
+        if (mode === "plain") {
+            options.write(verbose ? `${label}…\n` : `${label}… `);
+            try {
+                const value = await body();
+                options.write(verbose ? `${label}… done (${elapsed()})\n` : `done (${elapsed()})\n`);
+                return value;
+            }
+            catch (error) {
+                options.write(verbose
+                    ? `${label}… failed (${elapsed()})\n`
+                    : `failed (${elapsed()})\n`);
+                throw error;
+            }
+        }
+        let frame = 0;
+        const draw = () => {
+            const seconds = Math.floor((now() - at) / 1000);
+            options.write(`${CLEAR_LINE}${SPINNER[frame % SPINNER.length]} ${label}…${seconds > 0 ? DIM(` ${seconds}s`) : ""}`);
+            frame += 1;
+        };
+        draw();
+        const timer = setInterval(draw, options.interval ?? 80);
+        timer.unref?.();
+        try {
+            const value = await body();
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${GREEN("✓")} ${label} ${DIM(elapsed())}\n`);
+            return value;
+        }
+        catch (error) {
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${RED("✗")} ${label} ${DIM(elapsed())}\n`);
+            throw error;
+        }
+    };
+    return {
+        step,
+        output: (chunk) => {
+            if (verbose) {
+                options.write(chunk);
+            }
+        },
+        finish: (prefix, what) => {
+            if (mode !== "off") {
+                options.write(`${prefix}: ${what} in ${formatElapsed(now() - started)}.\n`);
+            }
+        },
+        verbose,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/cli",
-  "version": "0.1.0-pilot.4",
+  "version": "1.0.0-rc.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Scaffolds an Aventara server: `aventara new` for a new NestJS project, `aventara init` for an existing one.",
   "type": "module",
@@ -12,7 +12,8 @@
   },
   "files": [
     "dist",
-    "LICENSE-ADDITIONAL-PERMISSION.md"
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -23,7 +24,7 @@
   },
   "scripts": {
     "prebuild": "node scripts/adapter-catalog.generator.ts",
-    "build": "tsc -p tsconfig.json --removeComments --declaration false",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
     "lint": "biome lint src scripts"

package/dist/apply/app-module.anchor.d.ts

@@ -1,24 +0,0 @@
-/**
- * The scan is string- and comment-aware (a `@Module(` or an `imports: [` inside a
- * comment, a string or a template literal is not code), and it never reformats:
- * everything outside the two insertion points keeps its bytes. When the anchor is
- * not found exactly once — two `@Module`s, a computed `imports`, no `imports` at
- * all — nothing is edited and the caller prints the lines to add instead.
- */
-export type AppModuleWiring = {
-    /** Complete import declarations, one per line. */
-    readonly imports: readonly string[];
-    /** `imports:` entries, each possibly multi-line, each ending with a comma. */
-    readonly entries: readonly string[];
-};
-export type AppModuleEdit = {
-    readonly kind: "edited";
-    readonly text: string;
-} | {
-    readonly kind: "not-anchored";
-    readonly reason: string;
-};
-/** Splices `wiring` into `text` at the anchor, or says why there is no anchor. */
-export declare function spliceAppModule(text: string, wiring: AppModuleWiring): AppModuleEdit;
-/** What to add by hand when there is no anchor. */
-export declare function wiringInstructions(wiring: AppModuleWiring): string;

package/dist/apply/conflict.confirmer.d.ts

@@ -1,15 +0,0 @@
-import type { Prompter } from "../wizard/answer.resolver.js";
-/** Nobody confirmed replacing existing content. A refusal: nothing was touched. */
-export declare class ConflictsNotConfirmedError extends Error {
-    readonly name = "ConflictsNotConfirmedError";
-}
-export declare function conflictWarning(conflicts: readonly string[]): string;
-/**
- * Resolves when `conflicts` may be replaced; throws when they may not.
- *
- * @throws ConflictsNotConfirmedError
- */
-export declare function confirmConflicts(conflicts: readonly string[], consent: {
-    readonly yes: boolean;
-    readonly prompter: Prompter;
-}): Promise<void>;

package/dist/apply/e2e-spec.anchor.d.ts

@@ -1,18 +0,0 @@
-/**
- * pilot.1 — the scaffold's own e2e spec also proves the protocol is mounted.
- *
- * `nest new`'s `test/app.e2e-spec.ts` (`@nestjs/schematics` 12's template, ESM
- * and CommonJS alike) tests `GET /` and nothing else. Like the `app.module.ts`
- * edit, this one is anchored on Nest's exact text: the `/ (GET)` test is found
- * exactly once, and a `GET <entrypoint>/_contract` test is added right after
- * it, through the spec's own `app` and `request`. A spec that is not Nest's —
- * the developer's own — is left as it is, and nothing is said: the test is a
- * convenience, and the developer's tests are theirs.
- */
-/** The e2e spec `nest new` writes. */
-export declare const E2E_SPEC = "test/app.e2e-spec.ts";
-/**
- * `spec` with the contract test after Nest's `GET /` test, or `undefined` when
- * the anchor is not there exactly once, or the contract test already is.
- */
-export declare function spliceContractTest(spec: string, entrypoint: string): string | undefined;

package/dist/apply/main-cors.anchor.d.ts

@@ -1,50 +0,0 @@
-/**
- * pilot.3 — the scaffold turns CORS on in `src/main.ts` for the origins listed in
- * `CORS_ORIGINS`, so a browser frontend on another port (Vite's 5173, a Next.js
- * dev server on 3001) can call the protocol:
- *
- * const corsOrigins = (process.env.CORS_ORIGINS ?? '')…filter(Boolean);
- * app.enableCors({ origin: corsOrigins.length > 0 ? corsOrigins : false });
- *
- * followed by a commented-out platform-level rate limiter.
- *
- * **Unset or empty is OFF, never open.** The `cors` package Nest's Express
- * platform uses — and `@fastify/cors` — answer `Access-Control-Allow-Origin: *`
- * when given no origin, so the list is never passed through as it is: no origin is
- * `false`, CORS disabled.
- *
- * Like the `app.module.ts` edit, this one is anchored and never reformats: the
- * lines are inserted after the one statement that creates the application — `const
- * app = await NestFactory.create(…);`, found in code exactly once — through its
- * own variable. A `main.ts` that already configures CORS (`enableCors`, or a
- * `cors` option given to `NestFactory.create`) is the developer's decision and is
- * left as it is; one with no such statement is not edited, and the lines are
- * printed instead.
- */
-/** The variable the inserted lines read. */
-export declare const CORS_ORIGINS_VARIABLE = "CORS_ORIGINS";
-/** What the scaffold's `.env` lists: Vite's dev server, and a Next.js one beside Nest's 3000. */
-export declare const SCAFFOLD_CORS_ORIGINS = "http://localhost:5173,http://localhost:3001";
-/** The main file `nest new` writes. */
-export declare const MAIN_FILE = "src/main.ts";
-export type MainCorsEdit = 
-/** The lines were inserted. */
-{
-    readonly kind: "edited";
-    readonly text: string;
-}
-/** The lines are already there: a previous run's edit. */
- | {
-    readonly kind: "present";
-}
-/** The developer configures CORS: nothing is changed. */
- | {
-    readonly kind: "configured";
-} | {
-    readonly kind: "not-anchored";
-    readonly reason: string;
-};
-/** Splices the CORS lines into `text`, or says why they are not. */
-export declare function spliceMainCors(text: string): MainCorsEdit;
-/** What to add by hand when there is no anchor. */
-export declare function mainCorsInstructions(): string;

package/dist/apply/manifest.merger.d.ts

@@ -1,51 +0,0 @@
-/**
- * The merges `aventara init` makes into files a project already has —
- * `package.json`, `.env`, `.gitignore`, `pnpm-workspace.yaml` — each answering the
- * merged text and the **conflicts**: values already there that differ from what
- * would be written (the `generateAt` rule's "content the tool did not produce"). A
- * value already equal to what would be written is no change; a conflict is
- * replaced only once confirmed (`conflict.confirmer.ts`), so each merge is
- * computed with conflicts both kept and replaced.
- */
-export type Merge = {
-    readonly text: string;
-    /** What differs, named for the person asked: `package.json's scripts["postinstall"]`. */
-    readonly conflicts: readonly string[];
-};
-export type PackageManifest = {
-    readonly [key: string]: unknown;
-    readonly dependencies?: Readonly<Record<string, string>>;
-    readonly devDependencies?: Readonly<Record<string, string>>;
-    readonly scripts?: Readonly<Record<string, string>>;
-};
-export type ManifestChanges = {
-    readonly dependencies: Readonly<Record<string, string>>;
-    readonly devDependencies: Readonly<Record<string, string>>;
-    /** Scripts to set; a different existing value is a conflict. */
-    readonly scripts: Readonly<Record<string, string>>;
-    /**
-     * Scripts to rewrite only from a known value: `from` → `to`. Any other existing
-     * value is a conflict; an absent script is left absent.
-     */
-    readonly rewrites: Readonly<Record<string, {
-        readonly from: string;
-        readonly to: string;
-    }>>;
-};
-/** `package.json`, in npm's own layout: two-space JSON, dependencies sorted. */
-export declare function mergePackageManifest(text: string, changes: ManifestChanges, replaceConflicts: boolean): Merge;
-/** `.env`: a missing key is appended as `KEY="value"`, after a final newline. */
-export declare function mergeEnvFile(text: string | undefined, entries: Readonly<Record<string, string>>, replaceConflicts: boolean): Merge;
-/**
- * pilot.3 — `.env`: `KEY="value"` appended after a final newline when no line sets
- * `key`; a line that does is the developer's, never a conflict, and nothing else
- * is reordered or rewritten.
- */
-export declare function appendEnvEntryIfAbsent(text: string | undefined, key: string, value: string): string;
-/** `.gitignore`: missing lines appended, nothing else touched. */
-export declare function mergeGitignore(text: string | undefined, additions: readonly string[]): Merge;
-/**
- * Keys missing under an existing `allowBuilds:` are added there; otherwise the
- * block is appended.
- */
-export declare function mergePnpmWorkspace(text: string | undefined, packages: readonly string[]): Merge;

package/dist/aventara.bin.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};