@aventara/cli 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/project/project.inspector.js

@@ -1,12 +1,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { frameworkMajorOf, HOSTS, } from "../catalog/host-entry.interface.js";
 import { lowestMajorOf } from "../catalog/range.reader.js";
-export class ProjectRefusedError extends Error {
-    name = "ProjectRefusedError";
+export class AvProjectRefusedError extends Error {
+    name = "AvProjectRefusedError";
 }
-const NEST_MAJOR = 12;
 const FIRST_UNSUPPORTED_TYPESCRIPT = 7;
 export const APP_MODULE = "src/app.module.ts";
+const NEXT_APP_DIRECTORY = "src/app";
+const SOURCE_ALIAS = /"@\/\*"\s*:\s*\[\s*"\.\/src\/\*"\s*\]/;
 const LOCKFILES = [
     ["package-lock.json", "npm"],
     ["pnpm-lock.yaml", "pnpm"],
@@ -20,36 +22,72 @@ function matchesFamily(pattern, name) {
         ? name.startsWith(pattern.slice(0, -1))
         : name === pattern;
 }
+function servedProjects() {
+    const named = HOSTS.map((host) => `${host.label} ${frameworkMajorOf(host)}`);
+    return named.length <= 1
+        ? named.join("")
+        : `${named.slice(0, -1).join(", ")} or ${named[named.length - 1]}`;
+}
+function detectHost(manifest) {
+    const found = HOSTS.filter((host) => dependencyRange(manifest, host.framework.package) !== undefined);
+    const frameworks = HOSTS.map((host) => host.framework.package);
+    if (found.length === 0) {
+        throw new AvProjectRefusedError(`aventara init runs in a ${servedProjects()} project, and this package.json depends on ${frameworks.length === 2
+            ? `neither ${frameworks[0]} nor ${frameworks[1]}`
+            : `none of ${frameworks.join(", ")}`}`);
+    }
+    if (found.length > 1) {
+        throw new AvProjectRefusedError(`this package.json depends on both ${found.map((host) => host.framework.package).join(" and ")}, so aventara init cannot tell whether it is a ${found.map((host) => host.label).join(" or a ")} project; Aventara is hosted by one of them`);
+    }
+    return found[0];
+}
+const HOST_REFUSALS = {
+    nest: (directory) => {
+        const appModule = path.join(directory, APP_MODULE);
+        if (existsSync(appModule) &&
+            /\bAventaraModule\b/.test(readFileSync(appModule, "utf8"))) {
+            throw new AvProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
+        }
+    },
+    next: (directory, manifest, host) => {
+        if (dependencyRange(manifest, host.package) !== undefined) {
+            throw new AvProjectRefusedError(`this project is already initialized: package.json depends on ${host.package}`);
+        }
+        if (!existsSync(path.join(directory, NEXT_APP_DIRECTORY))) {
+            throw new AvProjectRefusedError(`aventara init serves a Next.js app built with the App Router in ${NEXT_APP_DIRECTORY}/, and this project has no ${NEXT_APP_DIRECTORY}/ (the Pages Router, and an app/ outside src/, are not served)`);
+        }
+        const tsconfig = path.join(directory, "tsconfig.json");
+        if (!existsSync(tsconfig) ||
+            !SOURCE_ALIAS.test(readFileSync(tsconfig, "utf8"))) {
+            throw new AvProjectRefusedError('the scaffold imports its server entry as @/aventara/server, and this project\'s tsconfig.json maps no "@/*" to "./src/*"; add "paths": { "@/*": ["./src/*"] } to its compilerOptions, as create-next-app writes it');
+        }
+    },
+};
 export function inspectProject(directory, catalog) {
     const manifestPath = path.join(directory, "package.json");
     if (!existsSync(manifestPath)) {
-        throw new ProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and there is no package.json in ${directory}`);
+        throw new AvProjectRefusedError(`aventara init runs in a ${servedProjects()} project, and there is no package.json in ${directory}`);
     }
     const manifestText = readFileSync(manifestPath, "utf8");
     const manifest = JSON.parse(manifestText);
-    const nest = dependencyRange(manifest, "@nestjs/core");
-    if (nest === undefined) {
-        throw new ProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and this package.json has no @nestjs/core dependency`);
-    }
-    if (lowestMajorOf(nest) !== NEST_MAJOR) {
-        throw new ProjectRefusedError(`aventara init supports NestJS ${NEST_MAJOR} only, and this project depends on @nestjs/core ${nest}`);
+    const host = detectHost(manifest);
+    const declared = dependencyRange(manifest, host.framework.package);
+    const major = frameworkMajorOf(host);
+    if (lowestMajorOf(declared) !== major) {
+        throw new AvProjectRefusedError(`aventara init supports ${host.label} ${major} only, and this project depends on ${host.framework.package} ${declared}`);
     }
     const typescript = dependencyRange(manifest, "typescript");
     const typescriptMajor = typescript === undefined ? undefined : lowestMajorOf(typescript);
     if (typescriptMajor !== undefined &&
         typescriptMajor >= FIRST_UNSUPPORTED_TYPESCRIPT) {
-        throw new ProjectRefusedError(`this project declares typescript ${typescript}, and TypeScript ${FIRST_UNSUPPORTED_TYPESCRIPT} has no classic compiler API for Aventara's generate steps to read types with; use TypeScript 6 or 5`);
+        throw new AvProjectRefusedError(`this project declares typescript ${typescript}, and TypeScript ${FIRST_UNSUPPORTED_TYPESCRIPT} has no classic compiler API for Aventara's generate steps to read types with; use TypeScript 5.7 to 6`);
     }
     const lockfiles = LOCKFILES.filter(([file]) => existsSync(path.join(directory, file))).map(([, manager]) => manager);
     const known = lockfiles.filter((manager) => manager !== "yarn");
     if (lockfiles.includes("yarn") && known.length === 0) {
-        throw new ProjectRefusedError("this project has only a yarn.lock, and aventara init supports npm and pnpm");
-    }
-    const appModule = path.join(directory, APP_MODULE);
-    if (existsSync(appModule) &&
-        /\bAventaraModule\b/.test(readFileSync(appModule, "utf8"))) {
-        throw new ProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
+        throw new AvProjectRefusedError("this project has only a yarn.lock, and aventara init supports npm and pnpm");
     }
+    HOST_REFUSALS[host.alias](directory, manifest, host);
     const dependencies = [
         ...Object.keys(manifest.dependencies ?? {}),
         ...Object.keys(manifest.devDependencies ?? {}),
@@ -64,6 +102,7 @@ export function inspectProject(directory, catalog) {
         };
     return {
         directory,
+        host,
         manifest,
         manifestText,
         moduleKind: manifest.type === "module" ? "esm" : "cjs",

package/dist/run/command.runner.js

@@ -1,22 +1,40 @@
 import { spawn } from "node:child_process";
-export const runCommand = (command, args, options) => new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-        cwd: options.cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: process.env,
+export const runCommand = (command, args, options) => options.interactive === true
+    ? runInteractive(command, args, options.cwd)
+    : runPiped(command, args, options);
+function runInteractive(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            resolve({ code: code ?? 1, stdout: "", stderr: "" });
+        });
     });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => {
-        stdout += chunk;
-        options.onOutput?.(chunk);
+}
+function runPiped(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        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) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
     });
-    child.stderr.setEncoding("utf8").on("data", (chunk) => {
-        stderr += chunk;
-        options.onOutput?.(chunk);
-    });
-    child.once("error", reject);
-    child.once("close", (code) => {
-        resolve({ code: code ?? 1, stdout, stderr });
-    });
-});
+}

package/dist/run/init.orchestrator.js

@@ -4,17 +4,17 @@ import { confirmConflicts } from "../apply/conflict.confirmer.js";
 import { matchInstalledOrm, matchOrmSetup, } from "../catalog/catalog.matcher.js";
 import { planInit } from "../plan/project.planner.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
-import { inspectProject, ProjectRefusedError, } from "../project/project.inspector.js";
+import { AvProjectRefusedError, inspectProject, } from "../project/project.inspector.js";
 import { scanServices } from "../project/service.detector.js";
-import { templatesFor, } from "../templates/template.registry.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 class AvInstallFailedError extends Error {
+    name = "AvInstallFailedError";
 }
 export async function runInit(command, io) {
     const { progress, nextSteps } = await initProject(command, io);
@@ -39,18 +39,15 @@ export async function initProject(command, io) {
     const prepared = inspection.orm.kind === "present"
         ? await prepareReuse(command, io, inspection, detectedPackageManager)
         : await prepareFresh(command, io, inspection, detectedPackageManager);
-    const { entry, provider, scaffold, packageManager } = prepared;
+    const { entry, provider, hosted, packageManager } = prepared;
     const plan = planInit({
         inspection,
         entry,
-        scaffold,
+        hosted,
         packageManager,
         aventaraVersion: io.aventaraVersion,
         skipInstall: command.skipInstall,
         read,
-        ...(prepared.wiringByHand === undefined
-            ? {}
-            : { wiringByHand: prepared.wiringByHand }),
         warnings: prepared.warnings,
     });
     await confirmConflicts(plan.conflicts, {
@@ -88,7 +85,7 @@ export async function initProject(command, io) {
                 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()}`);
+                throw new AvInstallFailedError(`\`${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()}`);
             }
         });
     }
@@ -105,16 +102,29 @@ async function prepareFresh(command, io, inspection, detectedPackageManager) {
     if (entry === undefined || db === undefined || packageManager === undefined) {
         throw new Error("the init questions settled without an ORM, database and package manager");
     }
+    const { hosts } = templatesFor(entry);
     return {
         entry,
         provider: db,
         packageManager,
-        scaffold: templatesFor(entry).scaffold({
-            entry,
-            provider: db,
-            moduleKind: inspection.moduleKind,
-            packageManager,
-        }),
+        hosted: inspection.host.alias === "nest"
+            ? {
+                host: "nest",
+                scaffold: hosts.nest.scaffold({
+                    entry,
+                    provider: db,
+                    moduleKind: inspection.moduleKind,
+                    packageManager,
+                }),
+            }
+            : {
+                host: "next",
+                scaffold: hosts.next.scaffold({
+                    entry,
+                    provider: db,
+                    packageManager,
+                }),
+            },
         warnings: [],
     };
 }
@@ -134,6 +144,10 @@ function installedVersion(directory, name) {
     }
 }
 async function prepareReuse(command, io, inspection, detectedPackageManager) {
+    if (inspection.host.alias !== "nest") {
+        const orm = inspection.orm;
+        throw new AvProjectRefusedError(`this ${inspection.host.label} project already uses ${orm.families.join(" and ")} (${orm.packages.join(", ")}), and aventara init sets an ORM up in a ${inspection.host.label} project that has none; it reuses an existing setup in a NestJS project only`);
+    }
     const dependencies = [
         ...Object.keys(inspection.manifest.dependencies ?? {}),
         ...Object.keys(inspection.manifest.devDependencies ?? {}),
@@ -144,25 +158,25 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
         installCommand: `${detectedPackageManager} install`,
     });
     if (verdict.kind === "refused") {
-        throw new ProjectRefusedError(verdict.sentence);
+        throw new AvProjectRefusedError(verdict.sentence);
     }
     const { entry } = verdict;
     const templates = templatesFor(entry);
     const facts = templates.readProject(io.directory, inspection.manifest);
     const problem = matchOrmSetup(entry, facts);
     if (problem !== undefined) {
-        throw new ProjectRefusedError(problem);
+        throw new AvProjectRefusedError(problem);
     }
     const provider = facts.provider;
     if (facts.clientOutput === undefined) {
-        throw new ProjectRefusedError(`this project's ${facts.generator} generator block in ${facts.schema} has no output, and the generate step reads the client from it; give it one, such as ../src/generated/${entry.orm.family}`);
+        throw new AvProjectRefusedError(`this project's ${facts.generator} generator block in ${facts.schema} has no output, and the generate step reads the client from it; give it one, such as ../src/generated/${entry.orm.family}`);
     }
     for (const [flag, given, found] of [
         ["--orm", command.given.orm, entry.alias],
         ["--db", command.given.db, provider],
     ]) {
         if (given !== undefined && given.trim().toLowerCase() !== found) {
-            throw new ProjectRefusedError(`${flag} ${given} does not match this project, which already uses ${found}`);
+            throw new AvProjectRefusedError(`${flag} ${given} does not match this project, which already uses ${found}`);
         }
     }
     const scan = scanServices(io.directory, templates.clientShape(facts));
@@ -176,9 +190,9 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
             services: {
                 scan,
                 clientClass: templates.clientShape(facts).clientClass,
-                newService: templates.newService.service,
-                newModule: templates.newService.module,
-                newServiceFileExists: existsSync(path.join(io.directory, templates.newService.service.file)),
+                newService: templates.hosts.nest.newService.service,
+                newModule: templates.hosts.nest.newService.module,
+                newServiceFileExists: existsSync(path.join(io.directory, templates.hosts.nest.newService.service.file)),
                 label: entry.orm.label,
             },
         },
@@ -202,28 +216,31 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
         ...(service.clientMember === undefined
             ? []
             : [
-                `${service.file}#${service.exportName} holds its client in .${service.clientMember} instead of extending ${templates.clientShape(facts).clientClass}, so src/aventara.config.ts passes ${service.exportName}.${service.clientMember}`,
+                `${service.file}#${service.exportName} holds its client in .${service.clientMember} instead of extending ${templates.clientShape(facts).clientClass}, so app.module.ts passes ${service.exportName}.${service.clientMember} to the adapter`,
             ]),
     ];
     return {
         entry,
         provider,
         packageManager,
-        scaffold: templates.reuse({
-            entry,
-            facts: { ...facts, provider, clientOutput: facts.clientOutput },
-            moduleKind: inspection.moduleKind,
-            packageManager,
-            service,
-            module,
-            writeService: service.isNew,
-            artifact,
-        }),
-        ...(service.clientMember === undefined
-            ? {}
-            : {
-                wiringByHand: `${service.exportName} holds its ${entry.orm.label} client instead of extending it`,
+        hosted: {
+            host: "nest",
+            scaffold: templates.hosts.nest.reuse({
+                entry,
+                facts: { ...facts, provider, clientOutput: facts.clientOutput },
+                moduleKind: inspection.moduleKind,
+                packageManager,
+                service,
+                module,
+                writeService: service.isNew,
+                artifact,
             }),
+            ...(service.clientMember === undefined
+                ? {}
+                : {
+                    wiringByHand: `${service.exportName} holds its ${entry.orm.label} client instead of extending it`,
+                }),
+        },
         warnings,
     };
 }

package/dist/run/new.orchestrator.js

@@ -1,19 +1,93 @@
 import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { DEFAULT_HOST, hostOf, } from "../catalog/host-entry.interface.js";
+import { AvCliCommandError, } from "../command/command.parser.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
-import { ProjectRefusedError } from "../project/project.inspector.js";
+import { AvProjectRefusedError } from "../project/project.inspector.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
-import { NEW_QUESTIONS } from "../wizard/wizard.questions.js";
-import { InstallFailedError, initProject, printNextSteps, } from "./init.orchestrator.js";
+import { NEW_QUESTIONS, } from "../wizard/wizard.questions.js";
+import { AvInstallFailedError, 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";
+const NEST_CLI = "@nestjs/cli@12.0.8";
+const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
+const NEXT_VERSION_VARIABLE = "AVENTARA_NEXT_VERSION";
+const NEXT_GENERATOR = "create-next-app";
+const VERSION = /^[0-9A-Za-z][0-9A-Za-z.+-]*$/;
+const NEXT_LAYOUT_FLAGS = [
+    "--ts",
+    "--app",
+    "--src-dir",
+    "--import-alias",
+    "@/*",
+];
 function oneOff(packageManager) {
     return packageManager === "pnpm" ? ["pnpm", ["dlx"]] : ["npx", ["-y"]];
 }
+const GENERATIONS = {
+    nest: ({ command, name, packageManager }) => {
+        if (command.passthrough !== undefined) {
+            throw new AvCliCommandError("arguments after -- go to create-next-app, so they need --host next; nest new takes only what aventara new passes it");
+        }
+        const [runner, prefix] = oneOff(packageManager);
+        return {
+            title: `Creating the NestJS project (${runner} ${[...prefix, NEST_CLI, "new", name].join(" ")})`,
+            command: runner,
+            args: [
+                ...prefix,
+                NEST_CLI,
+                "new",
+                name,
+                "--package-manager",
+                packageManager,
+                "--skip-install",
+                "--no-observe",
+                ...(command.skipGit ? ["--skip-git"] : []),
+            ],
+            interactive: false,
+            check: (directory) => {
+                const appModule = path.join(directory, "src", "app.module.ts");
+                const digest = existsSync(appModule)
+                    ? createHash("sha256").update(readFileSync(appModule)).digest("hex")
+                    : "(absent)";
+                if (digest !== NEST_APP_MODULE_SHA256) {
+                    throw new AvInstallFailedError(`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`);
+                }
+            },
+        };
+    },
+    next: ({ command, io, name, packageManager }) => {
+        const pinned = io.env[NEXT_VERSION_VARIABLE];
+        if (pinned !== undefined && pinned !== "" && !VERSION.test(pinned)) {
+            throw new AvCliCommandError(`${NEXT_VERSION_VARIABLE} is ${JSON.stringify(pinned)}, which is not a version of ${NEXT_GENERATOR}; set it to one such as 16.4.0, or unset it for the latest`);
+        }
+        if (!command.yes && !io.prompter.interactive) {
+            throw new AvCliCommandError(`${NEXT_GENERATOR} asks its own questions, and nobody can answer them here (stdin is not a terminal); pass --yes to take its defaults, and its own flags after --`);
+        }
+        const generator = `${NEXT_GENERATOR}@${pinned === undefined || pinned === "" ? "latest" : pinned}`;
+        const [runner, prefix] = oneOff(packageManager);
+        return {
+            title: `Creating the Next.js project (${runner} ${[...prefix, generator, name].join(" ")})`,
+            command: runner,
+            args: [
+                ...prefix,
+                generator,
+                name,
+                ...NEXT_LAYOUT_FLAGS,
+                `--use-${packageManager}`,
+                "--skip-install",
+                ...(command.skipGit ? ["--disable-git"] : []),
+                ...(command.yes ? ["--yes"] : []),
+                ...(command.passthrough ?? []),
+            ],
+            interactive: !command.yes,
+            check: () => { },
+        };
+    },
+};
 export async function runNew(command, io) {
+    const host = hostOf((command.host ?? DEFAULT_HOST));
     const answers = await resolveAnswers(NEW_QUESTIONS, {
         given: command.given,
         yes: command.yes,
@@ -32,47 +106,48 @@ export async function runNew(command, io) {
         packageManager === undefined) {
         throw new Error("the new questions settled without every answer");
     }
+    const generation = GENERATIONS[host.alias]({
+        command,
+        io,
+        name,
+        packageManager,
+    });
     const directory = path.join(io.cwd, name);
     if (existsSync(directory) && readdirSync(directory).length > 0) {
-        throw new ProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
+        throw new AvProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
     }
     const surroundings = command.skipGit
         ? undefined
         : await gitSurroundings(io.runner, io.cwd);
-    const [runner, prefix] = oneOff(packageManager);
-    const args = [
-        ...prefix,
-        NEST_CLI,
-        "new",
-        name,
-        "--package-manager",
-        packageManager,
-        "--skip-install",
-        "--no-observe",
-        ...(command.skipGit ? ["--skip-git"] : []),
-    ];
     const progress = createStepReporter({
         write: io.stderr,
         mode: io.progressMode,
-        total: 2 + (command.skipInstall ? 0 : 1) + (command.skipGit ? 0 : 1),
+        total: (generation.interactive ? 1 : 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, {
+    const generate = async () => {
+        const created = await io.runner(generation.command, generation.args, {
             cwd: io.cwd,
-            onOutput: progress.output,
+            ...(generation.interactive
+                ? { interactive: true }
+                : { 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()}`);
+            throw new AvInstallFailedError(`\`${generation.command} ${generation.args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again${generation.interactive
+                ? " (its output is above)"
+                : `:\n${created.stderr.trimEnd()}`}`);
         }
-    });
-    const appModule = path.join(directory, "src", "app.module.ts");
-    const digest = existsSync(appModule)
-        ? createHash("sha256").update(readFileSync(appModule)).digest("hex")
-        : "(absent)";
-    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`);
+    };
+    if (generation.interactive) {
+        io.stderr(`${generation.title}: it asks its own questions now.\n`);
+        await generate();
+    }
+    else {
+        await progress.step(generation.title, generate);
     }
+    generation.check(directory);
     const { nextSteps } = await initProject({
         command: "init",
         given: {

package/dist/run/scaffold.committer.js

@@ -1,5 +1,5 @@
 import { realpathSync } from "node:fs";
-export const INITIAL_COMMIT_MESSAGE = "Initial Aventara Scaffold";
+const INITIAL_COMMIT_MESSAGE = "Initial Aventara Scaffold";
 function isMissingCommand(error) {
     return (error instanceof Error &&
         error.code === "ENOENT");

package/dist/run/skill.orchestrator.js

@@ -0,0 +1,54 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { planAgentSkill } from "../skill/agent-skill.planner.js";
+export class AvSkillRefusedError extends Error {
+    name = "AvSkillRefusedError";
+}
+function readText(file) {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function runSkill(command, io) {
+    if (readText(path.join(io.directory, "package.json")) === undefined) {
+        throw new AvSkillRefusedError(`there is no package.json in ${io.directory}: run aventara skill in your project's root`);
+    }
+    const core = path.join(io.directory, "node_modules", "@aventara", "core");
+    const manifest = readText(path.join(core, "package.json"));
+    if (manifest === undefined) {
+        throw new AvSkillRefusedError("@aventara/core is not installed here: install the project's dependencies first, so the skill matches its version");
+    }
+    const coreVersion = JSON.parse(manifest)
+        .version;
+    const errors = readText(path.join(core, "ERRORS.md"));
+    const warnings = [];
+    if (coreVersion !== io.cliVersion) {
+        warnings.push(`this is @aventara/cli ${io.cliVersion} and the project has @aventara/core ${coreVersion}; for guidance written for that version run \`npx @aventara/cli@${coreVersion} skill\``);
+    }
+    if (errors === undefined) {
+        warnings.push(`@aventara/core ${coreVersion} ships no ERRORS.md, so reference/errors.md is this CLI's (${io.cliVersion})`);
+    }
+    const plan = planAgentSkill({
+        read: (file) => readText(path.join(io.directory, file)),
+        coreVersion,
+        ...(errors === undefined ? {} : { errors }),
+        force: command.force,
+    });
+    for (const write of plan.writes) {
+        const target = path.join(io.directory, write.path);
+        mkdirSync(path.dirname(target), { recursive: true });
+        writeFileSync(target, write.content);
+    }
+    for (const warning of [...warnings, ...plan.warnings]) {
+        io.stderr(`aventara: warning: ${warning}.\n`);
+    }
+    io.stdout(plan.writes.length === 0
+        ? `aventara: the agent skill for @aventara/core ${coreVersion} is up to date${plan.warnings.length === 0 ? "" : ", apart from what the warnings above name"}.\n`
+        : `aventara: wrote the agent skill for @aventara/core ${coreVersion}: ${plan.writes
+            .map((write) => `${write.change === "create" ? "created" : "updated"} ${write.path}`)
+            .join(", ")}.\n`);
+    return 0;
+}