@avleon/cli 0.0.46 → 0.4.0

package/dist/generators/make.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModel = makeModel;
+exports.makeService = makeService;
+exports.makeController = makeController;
+exports.makeConfig = makeConfig;
+exports.makeMiddleware = makeMiddleware;
+exports.makeDto = makeDto;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const log_1 = require("../utils/log");
+const names_1 = require("../utils/names");
+const project_1 = require("../utils/project");
+const stubs_1 = require("../utils/stubs");
+const DEFAULT_DIRS = {
+    model: "models",
+    service: "services",
+    controller: "controllers",
+    config: "config",
+    middleware: "middlewares",
+    dto: "dtos",
+};
+function targetDir(projectRoot, kind, dirs, root) {
+    const folder = root ? root.split(/[\\/]+/).filter(Boolean) : [DEFAULT_DIRS[kind]];
+    if (folder.some((p) => p === ".."))
+        throw new errors_1.CliError(`Invalid --root "${root}".`);
+    return path_1.default.join(projectRoot, "src", ...folder, ...dirs);
+}
+/** A relative module specifier from `fromFile` to `toFile` (without extension), always using `/`. */
+function importPath(fromFile, toFile) {
+    let rel = path_1.default.relative(path_1.default.dirname(fromFile), toFile).replace(/\.ts$/, "").split(path_1.default.sep).join("/");
+    if (!rel.startsWith("."))
+        rel = "./" + rel;
+    return rel;
+}
+function write(file, content, force, label, projectRoot) {
+    (0, project_1.writeFileSafe)(file, content, force);
+    log_1.log.success(`${label} created: ${path_1.default.relative(projectRoot, file).split(path_1.default.sep).join("/")}`);
+    return file;
+}
+/**
+ * Write a dependency of the requested file (the model behind a service, or the
+ * service behind a controller). An existing file is always kept and reused.
+ */
+function ensureDependency(file, render, label, projectRoot) {
+    const rel = path_1.default.relative(projectRoot, file).split(path_1.default.sep).join("/");
+    if (fs_1.default.existsSync(file)) {
+        log_1.log.info(`  ${label} exists, reusing: ${rel}`);
+        return;
+    }
+    write(file, render(), false, label, projectRoot);
+}
+function makeModel(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Model");
+    const file = path_1.default.join(targetDir(projectRoot, "model", n.dirs, opts.root), `${n.fileBase}.model.ts`);
+    return write(file, renderModel(n.base, opts.orm), opts.force, "Model", projectRoot);
+}
+function renderModel(model, orm) {
+    return (0, stubs_1.renderStub)(orm ? "models/entity-model.stub" : "models/basic-model.stub", {
+        Model: model,
+        table: (0, names_1.snakeCase)(model),
+    });
+}
+/**
+ * Write a resource service for `model` at `serviceFile`, plus the model under
+ * `src/models` if it does not exist yet, so the generated code compiles.
+ */
+function writeResourceService(projectRoot, serviceFile, serviceClass, model, orm, force, asDependency) {
+    const m = (0, names_1.resolveName)(model, "Model");
+    const modelFile = path_1.default.join(targetDir(projectRoot, "model", m.dirs), `${m.fileBase}.model.ts`);
+    const render = () => (0, stubs_1.renderStub)(orm ? "services/orm-rest-service.stub" : "services/rest-service.stub", {
+        ClassName: serviceClass,
+        Model: m.base,
+        modelVar: m.varName,
+        modelImport: importPath(serviceFile, modelFile),
+    });
+    if (asDependency)
+        ensureDependency(serviceFile, render, "Service", projectRoot);
+    else
+        write(serviceFile, render(), force, "Service", projectRoot);
+    ensureDependency(modelFile, () => renderModel(m.base, orm), "Model", projectRoot);
+    if (orm && !(0, project_1.installedVersion)("@avleon/data", projectRoot)) {
+        log_1.log.warn("The generated service uses @avleon/data. Install it: npm install @avleon/data typeorm");
+    }
+}
+function makeService(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Service");
+    const file = path_1.default.join(targetDir(projectRoot, "service", n.dirs, opts.root), `${n.fileBase}.service.ts`);
+    if (opts.resource && !opts.model) {
+        throw new errors_1.CliError("A resource service needs a model: pass -m <model> (or --model <model>).");
+    }
+    if (opts.model) {
+        writeResourceService(projectRoot, file, n.className, opts.model, opts.orm, opts.force, false);
+        return file;
+    }
+    return write(file, (0, stubs_1.renderStub)("services/basic-service.stub", { ClassName: n.className }), opts.force, "Service", projectRoot);
+}
+function makeController(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Controller");
+    const file = path_1.default.join(targetDir(projectRoot, "controller", n.dirs, opts.root), `${n.fileBase}.controller.ts`);
+    if (fs_1.default.existsSync(file) && !opts.force) {
+        throw new errors_1.CliError(`${file} already exists. Use -f or --force to overwrite it.`);
+    }
+    const route = [...n.dirs, `${n.fileBase}s`].join("/");
+    let content;
+    if (opts.model) {
+        const m = (0, names_1.resolveName)(opts.model, "Model");
+        const serviceClass = `${m.base}Service`;
+        const serviceFile = path_1.default.join(targetDir(projectRoot, "service", []), `${m.fileBase}.service.ts`);
+        content = (0, stubs_1.renderStub)("controllers/resource-controller.stub", {
+            ClassName: n.className,
+            route,
+            Model: m.base,
+            modelVar: m.varName,
+            ServiceClass: serviceClass,
+            serviceVar: `${m.varName}Service`,
+            serviceImport: importPath(file, serviceFile),
+        });
+        // Dependencies first, so a failure leaves no controller pointing at missing files.
+        writeResourceService(projectRoot, serviceFile, serviceClass, opts.model, opts.orm, false, true);
+    }
+    else {
+        const stub = opts.resource ? "controllers/rest-controller.stub" : "controllers/basic-controller.stub";
+        content = (0, stubs_1.renderStub)(stub, { ClassName: n.className, route });
+    }
+    if (opts.basePath) {
+        content = content.replace(/@ApiController\s*\(([^)]*)\)/, "@ApiController");
+    }
+    write(file, content, opts.force, "Controller", projectRoot);
+    log_1.log.info(`  Register it in your app: app.useControllers([..., ${n.className}])`);
+    return file;
+}
+function makeConfig(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Config");
+    const file = path_1.default.join(targetDir(projectRoot, "config", n.dirs, opts.root), `${n.fileBase}.config.ts`);
+    return write(file, (0, stubs_1.renderStub)("config/config.stub", { ClassName: n.className }), opts.force, "Config", projectRoot);
+}
+function makeMiddleware(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Middleware");
+    const file = path_1.default.join(targetDir(projectRoot, "middleware", n.dirs, opts.root), `${n.fileBase}.middleware.ts`);
+    return write(file, (0, stubs_1.renderStub)("middlewares/middleware.stub", { ClassName: n.className }), opts.force, "Middleware", projectRoot);
+}
+function makeDto(name, opts = {}) {
+    const projectRoot = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    const n = (0, names_1.resolveName)(name, "Dto");
+    const file = path_1.default.join(targetDir(projectRoot, "dto", n.dirs, opts.root), `${n.fileBase}.dto.ts`);
+    return write(file, (0, stubs_1.renderStub)("dtos/dto.stub", { ClassName: n.className }), opts.force, "DTO", projectRoot);
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Library entry for `@avleon/cli`. Importing it has no side effects; the
+ * executable lives in `bin.ts`.
+ */
+export { runCli, createProgram, normalizeArgv } from "./program";
+export type { RunOptions } from "./program";
+export { CliError } from "./errors";
+export { createApplication } from "./commands/new";
+export type { NewOptions } from "./commands/new";
+export { build } from "./commands/build";
+export { serve } from "./commands/serve";
+export { start } from "./commands/start";
+export { doctor, runChecks } from "./commands/doctor";
+export { routeList, scanRoutes } from "./commands/route-list";
+export { makeModel, makeController, makeService, makeConfig, makeMiddleware, makeDto, } from "./generators/make";
+export { resolveName, pascalCase, camelCase, kebabCase, snakeCase } from "./utils/names";
+export { findProjectRoot } from "./utils/project";

package/dist/index.js

@@ -1,17 +1,42 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./cli"), exports);
+exports.findProjectRoot = exports.snakeCase = exports.kebabCase = exports.camelCase = exports.pascalCase = exports.resolveName = exports.makeDto = exports.makeMiddleware = exports.makeConfig = exports.makeService = exports.makeController = exports.makeModel = exports.scanRoutes = exports.routeList = exports.runChecks = exports.doctor = exports.start = exports.serve = exports.build = exports.createApplication = exports.CliError = exports.normalizeArgv = exports.createProgram = exports.runCli = void 0;
+/**
+ * Library entry for `@avleon/cli`. Importing it has no side effects; the
+ * executable lives in `bin.ts`.
+ */
+var program_1 = require("./program");
+Object.defineProperty(exports, "runCli", { enumerable: true, get: function () { return program_1.runCli; } });
+Object.defineProperty(exports, "createProgram", { enumerable: true, get: function () { return program_1.createProgram; } });
+Object.defineProperty(exports, "normalizeArgv", { enumerable: true, get: function () { return program_1.normalizeArgv; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CliError", { enumerable: true, get: function () { return errors_1.CliError; } });
+var new_1 = require("./commands/new");
+Object.defineProperty(exports, "createApplication", { enumerable: true, get: function () { return new_1.createApplication; } });
+var build_1 = require("./commands/build");
+Object.defineProperty(exports, "build", { enumerable: true, get: function () { return build_1.build; } });
+var serve_1 = require("./commands/serve");
+Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return serve_1.serve; } });
+var start_1 = require("./commands/start");
+Object.defineProperty(exports, "start", { enumerable: true, get: function () { return start_1.start; } });
+var doctor_1 = require("./commands/doctor");
+Object.defineProperty(exports, "doctor", { enumerable: true, get: function () { return doctor_1.doctor; } });
+Object.defineProperty(exports, "runChecks", { enumerable: true, get: function () { return doctor_1.runChecks; } });
+var route_list_1 = require("./commands/route-list");
+Object.defineProperty(exports, "routeList", { enumerable: true, get: function () { return route_list_1.routeList; } });
+Object.defineProperty(exports, "scanRoutes", { enumerable: true, get: function () { return route_list_1.scanRoutes; } });
+var make_1 = require("./generators/make");
+Object.defineProperty(exports, "makeModel", { enumerable: true, get: function () { return make_1.makeModel; } });
+Object.defineProperty(exports, "makeController", { enumerable: true, get: function () { return make_1.makeController; } });
+Object.defineProperty(exports, "makeService", { enumerable: true, get: function () { return make_1.makeService; } });
+Object.defineProperty(exports, "makeConfig", { enumerable: true, get: function () { return make_1.makeConfig; } });
+Object.defineProperty(exports, "makeMiddleware", { enumerable: true, get: function () { return make_1.makeMiddleware; } });
+Object.defineProperty(exports, "makeDto", { enumerable: true, get: function () { return make_1.makeDto; } });
+var names_1 = require("./utils/names");
+Object.defineProperty(exports, "resolveName", { enumerable: true, get: function () { return names_1.resolveName; } });
+Object.defineProperty(exports, "pascalCase", { enumerable: true, get: function () { return names_1.pascalCase; } });
+Object.defineProperty(exports, "camelCase", { enumerable: true, get: function () { return names_1.camelCase; } });
+Object.defineProperty(exports, "kebabCase", { enumerable: true, get: function () { return names_1.kebabCase; } });
+Object.defineProperty(exports, "snakeCase", { enumerable: true, get: function () { return names_1.snakeCase; } });
+var project_1 = require("./utils/project");
+Object.defineProperty(exports, "findProjectRoot", { enumerable: true, get: function () { return project_1.findProjectRoot; } });

package/dist/program.d.ts

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+export type RunOptions = {
+    /** Working directory for the command. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Override where commander writes help and errors (used by tests). */
+    writeOut?: (s: string) => void;
+    writeErr?: (s: string) => void;
+};
+/**
+ * Legacy spellings commander cannot express directly: `-rt` (multi-letter
+ * short flag) and `--rest` (second long name for `--resource`).
+ */
+export declare function normalizeArgv(args: string[]): string[];
+export declare function createProgram(run?: RunOptions): {
+    program: Command;
+    exitCode: () => number;
+};
+/**
+ * Parse and run a command line (without the `node` and script entries).
+ * Resolves to the process exit code instead of exiting, so it can be tested.
+ */
+export declare function runCli(args: string[], run?: RunOptions): Promise<number>;

package/dist/program.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeArgv = normalizeArgv;
+exports.createProgram = createProgram;
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const build_1 = require("./commands/build");
+const doctor_1 = require("./commands/doctor");
+const new_1 = require("./commands/new");
+const route_list_1 = require("./commands/route-list");
+const serve_1 = require("./commands/serve");
+const start_1 = require("./commands/start");
+const errors_1 = require("./errors");
+const make_1 = require("./generators/make");
+const log_1 = require("./utils/log");
+const stubs_1 = require("./utils/stubs");
+/**
+ * Legacy spellings commander cannot express directly: `-rt` (multi-letter
+ * short flag) and `--rest` (second long name for `--resource`).
+ */
+function normalizeArgv(args) {
+    return args.map((a) => (a === "-rt" ? "--root" : a === "--rest" ? "--resource" : a));
+}
+function parseInteger(value) {
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 0)
+        throw new commander_1.InvalidArgumentError("Expected a non-negative integer.");
+    return n;
+}
+function parseList(value) {
+    return value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function createProgram(run = {}) {
+    const cwd = () => run.cwd ?? process.cwd();
+    let exitCode = 0;
+    const program = new commander_1.Command();
+    program
+        .name("avleon")
+        .description("Scaffold, run and build Avleon applications.")
+        .version((0, stubs_1.cliVersion)(), "-v, --version", "Print the CLI version")
+        .helpOption("-h, --help", "Show help")
+        .helpCommand("help [command]", "Show help for a command")
+        .showHelpAfterError("(run `avleon --help` for usage)")
+        .showSuggestionAfterError(true)
+        .exitOverride();
+    if (run.writeOut || run.writeErr) {
+        program.configureOutput({
+            ...(run.writeOut ? { writeOut: run.writeOut } : {}),
+            ...(run.writeErr ? { writeErr: run.writeErr } : {}),
+        });
+    }
+    const sub = (name, description) => {
+        const cmd = program.command(name).description(description).helpOption("-h, --help", "Show help");
+        cmd.exitOverride();
+        if (run.writeOut || run.writeErr)
+            cmd.configureOutput(program.configureOutput());
+        return cmd;
+    };
+    // ── Project ─────────────────────────────────────────────────────────────
+    sub("new", "Create a new Avleon application")
+        .argument("<name>", "Project directory (created if missing); `.` for the current directory")
+        .option("-m, --minimal", "Minimal app: a single functional route, no controllers, services or tests")
+        .option("-f, --force", "Scaffold into a non-empty directory, overwriting generated files")
+        .option("-y, --yes", "Skip prompts and use defaults (npm, openapi)")
+        .option("--pm <manager>", `Package manager: ${new_1.PACKAGE_MANAGERS.join(", ")}`)
+        .option("--features <list>", `Comma-separated features: ${new_1.FEATURES.join(", ")}`, parseList)
+        .option("--skip-install", "Do not install dependencies (or set AVLEON_SKIP_INSTALL=1)")
+        .action(async (name, o) => {
+        await (0, new_1.createApplication)(name, { cwd: cwd(), ...o });
+    });
+    sub("serve", "Start the dev server: compile src/ with SWC, run the app, reload on changes")
+        .option("--entry <file>", "Entry file, overriding avleon.entry / main in package.json")
+        .option("--no-type-check", "Do not run `tsc --noEmit --watch` alongside the server")
+        .option("--debounce <ms>", "Wait this long for more file changes before reloading", parseInteger, 200)
+        .action(async (o) => {
+        await (0, serve_1.serve)({ cwd: cwd(), entry: o.entry, typeCheck: o.typeCheck, debounce: o.debounce });
+    });
+    sub("build", "Compile with tsc (tsconfig.build.json, else tsconfig.json) and copy assets")
+        .option("-p, --project <file>", "Use this tsconfig instead")
+        .action(async (o) => {
+        await (0, build_1.build)({ cwd: cwd(), project: o.project });
+    });
+    sub("start", "Run the compiled app in production (NODE_ENV=production unless set)")
+        .option("--entry <file>", "Entry file, overriding avleon.entry / main in package.json")
+        .action(async (o) => {
+        exitCode = await (0, start_1.start)({ cwd: cwd(), entry: o.entry });
+    });
+    sub("doctor", "Check Node.js, @avleon/core, reflect-metadata and decorator settings")
+        .action(() => {
+        exitCode = (0, doctor_1.doctor)(cwd());
+    });
+    sub("route:list", "List the app's routes")
+        .alias("routes")
+        .option("--json", "Print JSON")
+        .option("--static", "Scan @ApiController/@Get/@Post/... decorators in src/**/*.controller.ts instead of loading the code")
+        .addHelpText("after", "\nBy default the sources are compiled with SWC to node_modules/.cache/avleon and each\n" +
+        "*.controller.ts is loaded in a child process to read Avleon's route metadata, so\n" +
+        "@avleon/core must be installed. --static needs no dependencies but only understands\n" +
+        "string-literal paths.")
+        .action((o) => {
+        (0, route_list_1.routeList)({ cwd: cwd(), json: o.json, static: o.static });
+    });
+    // ── Generators ──────────────────────────────────────────────────────────
+    const make = (name, aliases, description) => sub(name, description)
+        .aliases(aliases)
+        .argument("<name>", "Name, optionally nested (e.g. admin/User)")
+        .option("-f, --force", "Overwrite the file if it exists");
+    make("make:model", ["m:m"], "Create a model in src/models/<name>.model.ts")
+        .option("--orm", "Generate a TypeORM entity")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .action((name, o) => {
+        (0, make_1.makeModel)(name, { cwd: cwd(), ...o });
+    });
+    make("make:controller", ["m:c"], "Create a controller in src/controllers/<name>.controller.ts")
+        .option("-r, --resource", "Generate a REST skeleton (also --rest)")
+        .option("-m, --model <model>", "Back a REST controller with <model>: also creates its service and model if missing")
+        .option("--orm", "With -m, back the service with a TypeORM repository and entity")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .option("--base-path", "Use @ApiController without a path prefix")
+        .action((name, o) => {
+        (0, make_1.makeController)(name, { cwd: cwd(), ...o });
+    });
+    make("make:service", ["m:s"], "Create a service in src/services/<name>.service.ts")
+        .option("-r, --resource", "Generate a resource (CRUD) service; requires -m (also --rest)")
+        .option("-m, --model <model>", "Model for a resource service; creates the model if missing")
+        .option("--orm", "Back the resource service with a TypeORM repository and entity")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .action((name, o) => {
+        (0, make_1.makeService)(name, { cwd: cwd(), ...o });
+    });
+    make("make:config", ["m:cnf", "m:cfg"], "Create an @AppConfig class in src/config/<name>.config.ts")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .action((name, o) => {
+        (0, make_1.makeConfig)(name, { cwd: cwd(), ...o });
+    });
+    make("make:middleware", ["m:mlwr", "m:mdlr"], "Create a middleware in src/middlewares/<name>.middleware.ts")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .action((name, o) => {
+        (0, make_1.makeMiddleware)(name, { cwd: cwd(), ...o });
+    });
+    make("make:dto", ["m:dto"], "Create a class-validator DTO in src/dtos/<name>.dto.ts")
+        .option("--root <dir>", "Folder under src/ to write to (also -rt)")
+        .action((name, o) => {
+        (0, make_1.makeDto)(name, { cwd: cwd(), ...o });
+    });
+    return { program, exitCode: () => exitCode };
+}
+/**
+ * Parse and run a command line (without the `node` and script entries).
+ * Resolves to the process exit code instead of exiting, so it can be tested.
+ */
+async function runCli(args, run = {}) {
+    const { program, exitCode } = createProgram(run);
+    const argv = normalizeArgv(args);
+    if (argv.length === 0) {
+        program.outputHelp();
+        return 0;
+    }
+    try {
+        await program.parseAsync(argv, { from: "user" });
+        return exitCode();
+    }
+    catch (err) {
+        if (err instanceof commander_1.CommanderError) {
+            // Help and version are reported as "errors" with exit code 0.
+            return err.exitCode;
+        }
+        if (err instanceof errors_1.CliError) {
+            log_1.log.error(err.message);
+            return err.exitCode;
+        }
+        log_1.log.error(err instanceof Error ? (err.stack ?? err.message) : String(err));
+        return 1;
+    }
+}

package/dist/utils/entry.d.ts

@@ -0,0 +1,15 @@
+export type ProjectLayout = {
+    root: string;
+    srcDir: string;
+    outDir: string;
+    compilerOptions: Record<string, any>;
+    tsconfig: string | null;
+};
+export declare function projectLayout(root: string, preferBuildConfig?: boolean): ProjectLayout;
+/**
+ * Candidate entry files, most specific first: `--entry`, `avleon.entry` in
+ * package.json, `main` (mapped from `src/*.ts` to the output dir), then the
+ * conventional names in the output dir.
+ */
+export declare function entryCandidates(layout: ProjectLayout, pkg: Record<string, any>, explicit?: string): string[];
+export declare function resolveEntry(candidates: string[], explicit?: string): string | null;

package/dist/utils/entry.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectLayout = projectLayout;
+exports.entryCandidates = entryCandidates;
+exports.resolveEntry = resolveEntry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const tsconfig_1 = require("./tsconfig");
+function projectLayout(root, preferBuildConfig = false) {
+    const tsconfig = (0, tsconfig_1.findTsConfig)(root, preferBuildConfig);
+    const compilerOptions = tsconfig ? (0, tsconfig_1.readTsConfig)(tsconfig).compilerOptions : {};
+    return {
+        root,
+        tsconfig,
+        compilerOptions,
+        srcDir: compilerOptions.rootDir ?? path_1.default.join(root, "src"),
+        outDir: compilerOptions.outDir ?? path_1.default.join(root, "dist"),
+    };
+}
+const DEFAULT_ENTRIES = ["serve.js", "server.js", "main.js", "index.js"];
+/**
+ * Candidate entry files, most specific first: `--entry`, `avleon.entry` in
+ * package.json, `main` (mapped from `src/*.ts` to the output dir), then the
+ * conventional names in the output dir.
+ */
+function entryCandidates(layout, pkg, explicit) {
+    const list = [];
+    const add = (p) => list.push(path_1.default.resolve(layout.root, p));
+    if (explicit)
+        add(explicit);
+    if (typeof pkg?.avleon?.entry === "string")
+        add(pkg.avleon.entry);
+    if (typeof pkg?.main === "string") {
+        const main = path_1.default.resolve(layout.root, pkg.main);
+        const rel = path_1.default.relative(layout.srcDir, main);
+        if (!rel.startsWith("..") && !path_1.default.isAbsolute(rel)) {
+            add(path_1.default.join(layout.outDir, rel).replace(/\.ts$/, ".js"));
+        }
+        else {
+            add(main);
+        }
+    }
+    for (const name of DEFAULT_ENTRIES)
+        add(path_1.default.join(layout.outDir, name));
+    return [...new Set(list)];
+}
+function resolveEntry(candidates, explicit) {
+    // An explicit --entry must exist itself; no silent fallback.
+    if (explicit)
+        return fs_1.default.existsSync(candidates[0]) ? candidates[0] : null;
+    return candidates.find((c) => fs_1.default.existsSync(c)) ?? null;
+}

package/dist/utils/env-types.d.ts

@@ -0,0 +1,8 @@
+/** File name of the generated declarations that load the app's plugin types. */
+export declare const ENV_TYPES_FILE = "avleon-env.d.ts";
+/**
+ * Contents of `avleon-env.d.ts`. Each Avleon plugin adds its app methods
+ * (such as `app.useKnex()` from `@avleon/data`) through declaration merging,
+ * which TypeScript only sees once the plugin's types are part of the project.
+ */
+export declare function envTypesFile(plugins: string[]): string;

package/dist/utils/env-types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENV_TYPES_FILE = void 0;
+exports.envTypesFile = envTypesFile;
+/** File name of the generated declarations that load the app's plugin types. */
+exports.ENV_TYPES_FILE = "avleon-env.d.ts";
+/**
+ * Contents of `avleon-env.d.ts`. Each Avleon plugin adds its app methods
+ * (such as `app.useKnex()` from `@avleon/data`) through declaration merging,
+ * which TypeScript only sees once the plugin's types are part of the project.
+ */
+function envTypesFile(plugins) {
+    return [
+        "// Generated by the Avleon CLI. Do not edit: it is rewritten when plugins change.",
+        "// It loads the types of the Avleon plugins this app depends on.",
+        ...[...plugins].sort().map((name) => `/// <reference types="${name}" />`),
+        "",
+    ].join("\n");
+}

package/dist/utils/log.d.ts

@@ -0,0 +1,25 @@
+export declare const c: {
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+    cyan: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    white: (s: string) => string;
+};
+export declare const icon: {
+    success: string;
+    error: string;
+    warn: string;
+    arrow: string;
+};
+export declare const log: {
+    info: (msg: string) => void;
+    step: (label: string, detail?: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    section: (title: string) => void;
+};
+/** Timestamped, category-prefixed logging used by the long-running commands. */
+export declare function tagged(category: string, color?: (s: string) => string): (message: string) => void;

package/dist/utils/log.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.icon = exports.c = void 0;
+exports.tagged = tagged;
+const useColor = !process.env.NO_COLOR && (process.env.FORCE_COLOR !== undefined || process.stdout.isTTY === true);
+const code = (open) => (s) => (useColor ? `\x1b[${open}m${s}\x1b[0m` : s);
+exports.c = {
+    dim: code("90"),
+    bold: code("1"),
+    cyan: code("36"),
+    green: code("32"),
+    yellow: code("33"),
+    red: code("31"),
+    white: code("37"),
+};
+exports.icon = {
+    success: exports.c.green("✔"),
+    error: exports.c.red("✖"),
+    warn: exports.c.yellow("⚠"),
+    arrow: exports.c.dim("→"),
+};
+exports.log = {
+    info: (msg) => console.log(msg),
+    step: (label, detail) => console.log(`  ${exports.icon.arrow} ${label.padEnd(30, " ")}${detail ? exports.c.dim(detail) : ""}`),
+    success: (msg) => console.log(`${exports.icon.success} ${msg}`),
+    warn: (msg) => console.warn(`${exports.icon.warn} ${exports.c.yellow(msg)}`),
+    error: (msg) => console.error(`${exports.icon.error} ${exports.c.red(msg)}`),
+    section: (title) => {
+        console.log(`\n${exports.c.bold(exports.c.cyan(`  ${title}`))}`);
+        console.log(`  ${"─".repeat(40)}`);
+    },
+};
+/** Timestamped, category-prefixed logging used by the long-running commands. */
+function tagged(category, color = exports.c.white) {
+    return (message) => {
+        const ts = new Date().toTimeString().split(" ")[0];
+        console.log(`${exports.c.dim(`[${ts}]`)} ${color(`[${category}]`)} ${message}`);
+    };
+}

package/dist/utils/names.d.ts

@@ -0,0 +1,27 @@
+/** Split an identifier into words: `JwtAuth`, `jwt-auth`, `jwt_auth` and `jwtAuth` all give `[jwt, auth]`. */
+export declare function words(input: string): string[];
+export declare const pascalCase: (input: string) => string;
+export declare const camelCase: (input: string) => string;
+export declare const kebabCase: (input: string) => string;
+export declare const snakeCase: (input: string) => string;
+/** Human-readable title, e.g. `my_api` -> `My Api`. */
+export declare const titleCase: (input: string) => string;
+export type ResolvedName = {
+    /** Sub-directories requested in the name, e.g. `["admin"]` for `admin/User`. */
+    dirs: string[];
+    /** PascalCase name without the suffix, e.g. `JwtAuth`. */
+    base: string;
+    /** PascalCase class name with the suffix, e.g. `JwtAuthConfig`. */
+    className: string;
+    /** camelCase base, e.g. `jwtAuth`. */
+    varName: string;
+    /** kebab-case base, e.g. `jwt-auth`. */
+    fileBase: string;
+};
+/**
+ * Resolve a user-supplied artifact name (optionally nested, e.g. `admin/User`
+ * or `admin\User`) into class and file names. A trailing suffix such as
+ * `Controller` is dropped before it is re-added, so `UserController` and `User`
+ * give the same result.
+ */
+export declare function resolveName(input: string, suffix?: string): ResolvedName;