@avleon/cli 0.0.47 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tareq Hossain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const program_1 = require("./program");
+(0, program_1.runCli)(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+}, (err) => {
+    console.error(err);
+    process.exitCode = 1;
+});

package/dist/commands/build.d.ts

@@ -0,0 +1,11 @@
+export type BuildOptions = {
+    cwd?: string;
+    project?: string;
+    quiet?: boolean;
+};
+/**
+ * Compile the project with its own `tsc`, using `tsconfig.build.json` (or
+ * `tsconfig.json` when there is none), then copy non-TS assets from the
+ * source dir into the output dir.
+ */
+export declare function build(opts?: BuildOptions): Promise<string>;

package/dist/commands/build.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const tsconfig_1 = require("../utils/tsconfig");
+const log_1 = require("../utils/log");
+const project_1 = require("../utils/project");
+const process_1 = require("../utils/process");
+/**
+ * Compile the project with its own `tsc`, using `tsconfig.build.json` (or
+ * `tsconfig.json` when there is none), then copy non-TS assets from the
+ * source dir into the output dir.
+ */
+async function build(opts = {}) {
+    const root = (0, project_1.requireProjectRoot)(opts.cwd ?? process.cwd());
+    let config;
+    if (opts.project) {
+        config = path_1.default.resolve(opts.cwd ?? process.cwd(), opts.project);
+        if (!fs_1.default.existsSync(config))
+            throw new errors_1.CliError(`${config} not found.`);
+    }
+    else if (fs_1.default.existsSync(path_1.default.join(root, "tsconfig.build.json"))) {
+        config = path_1.default.join(root, "tsconfig.build.json");
+    }
+    else if (fs_1.default.existsSync(path_1.default.join(root, "tsconfig.json"))) {
+        config = path_1.default.join(root, "tsconfig.json");
+        log_1.log.warn("tsconfig.build.json not found; building with tsconfig.json.");
+    }
+    else {
+        throw new errors_1.CliError(`No tsconfig.build.json or tsconfig.json found in ${root}.`);
+    }
+    const tsc = (0, process_1.findTsc)(root);
+    if (!tsc)
+        throw new errors_1.CliError("TypeScript is not installed in this project. Run `npm install -D typescript`.");
+    const configLayout = layoutOf(config, root);
+    fs_1.default.rmSync(configLayout.outDir, { recursive: true, force: true });
+    if (!opts.quiet)
+        log_1.log.info(`Compiling with ${path_1.default.relative(root, config)}...`);
+    const code = await (0, process_1.runNode)(tsc, ["--project", config], root);
+    if (code !== 0)
+        throw new errors_1.CliError(`Build failed: tsc exited with code ${code}.`, code || 1);
+    // tsc mirrors rootDir (or the common source root) into outDir.
+    const nestedOut = path_1.default.join(configLayout.outDir, path_1.default.relative(root, configLayout.srcDir));
+    const assetOut = !configLayout.explicitRootDir && fs_1.default.existsSync(nestedOut) ? nestedOut : configLayout.outDir;
+    const copied = (0, project_1.copyAssets)(configLayout.srcDir, assetOut);
+    if (!opts.quiet) {
+        if (copied)
+            log_1.log.info(`Copied ${copied} asset file(s) to ${path_1.default.relative(root, assetOut)}.`);
+        log_1.log.success("Build complete.");
+    }
+    return configLayout.outDir;
+}
+function layoutOf(config, root) {
+    const opts = (0, tsconfig_1.readTsConfig)(config).compilerOptions;
+    return {
+        outDir: opts.outDir ?? path_1.default.join(root, "dist"),
+        srcDir: opts.rootDir ?? path_1.default.join(root, "src"),
+        explicitRootDir: typeof opts.rootDir === "string",
+    };
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,10 @@
+export type CheckStatus = "ok" | "warn" | "fail";
+export type Check = {
+    name: string;
+    status: CheckStatus;
+    detail: string;
+};
+/** Run the environment checks. Pure apart from reading files, so it is easy to test. */
+export declare function runChecks(cwd: string, nodeVersion?: string): Check[];
+/** Print the checks and return the exit code: 1 if any check failed. */
+export declare function doctor(cwd?: string): number;

package/dist/commands/doctor.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecks = runChecks;
+exports.doctor = doctor;
+const path_1 = __importDefault(require("path"));
+const log_1 = require("../utils/log");
+const project_1 = require("../utils/project");
+const stubs_1 = require("../utils/stubs");
+const tsconfig_1 = require("../utils/tsconfig");
+const MIN_NODE_MAJOR = 20;
+const major = (v) => Number(v.replace(/^[^\d]*/, "").split(".")[0]);
+const minor = (v) => Number(v.replace(/^[^\d]*/, "").split(".")[1] ?? 0);
+/** Run the environment checks. Pure apart from reading files, so it is easy to test. */
+function runChecks(cwd, nodeVersion = process.versions.node) {
+    const checks = [];
+    const cli = (0, stubs_1.cliVersion)();
+    checks.push({
+        name: "Node.js",
+        status: major(nodeVersion) >= MIN_NODE_MAJOR ? "ok" : "fail",
+        detail: `v${nodeVersion} (requires >=${MIN_NODE_MAJOR})`,
+    });
+    checks.push({ name: "@avleon/cli", status: "ok", detail: `v${cli}` });
+    const root = (0, project_1.findProjectRoot)(cwd);
+    if (!root) {
+        checks.push({
+            name: "Project",
+            status: "fail",
+            detail: `no package.json found in ${path_1.default.resolve(cwd)} or its parents`,
+        });
+        return checks;
+    }
+    checks.push({ name: "Project", status: "ok", detail: root });
+    const core = (0, project_1.installedVersion)("@avleon/core", root);
+    if (!core) {
+        checks.push({ name: "@avleon/core", status: "fail", detail: "not installed (npm install @avleon/core)" });
+    }
+    else if (major(core) !== major(cli)) {
+        checks.push({
+            name: "@avleon/core",
+            status: "fail",
+            detail: `v${core} does not match CLI v${cli} (major versions must match)`,
+        });
+    }
+    else if (minor(core) !== minor(cli)) {
+        checks.push({ name: "@avleon/core", status: "warn", detail: `v${core}, CLI is v${cli} (minor versions differ)` });
+    }
+    else {
+        checks.push({ name: "@avleon/core", status: "ok", detail: `v${core} (matches CLI)` });
+    }
+    const reflect = (0, project_1.installedVersion)("reflect-metadata", root);
+    checks.push(reflect
+        ? { name: "reflect-metadata", status: "ok", detail: `v${reflect}` }
+        : { name: "reflect-metadata", status: "fail", detail: "not installed (npm install reflect-metadata)" });
+    const tsconfig = (0, tsconfig_1.findTsConfig)(root);
+    if (!tsconfig) {
+        checks.push({ name: "tsconfig.json", status: "fail", detail: "not found" });
+    }
+    else {
+        let opts = null;
+        try {
+            opts = (0, tsconfig_1.readTsConfig)(tsconfig).compilerOptions;
+        }
+        catch (err) {
+            checks.push({ name: "tsconfig.json", status: "fail", detail: `cannot parse: ${err.message}` });
+        }
+        if (opts) {
+            for (const flag of ["experimentalDecorators", "emitDecoratorMetadata"]) {
+                checks.push({
+                    name: flag,
+                    status: opts[flag] === true ? "ok" : "fail",
+                    detail: opts[flag] === true ? "enabled" : `set "${flag}": true in compilerOptions`,
+                });
+            }
+        }
+    }
+    return checks;
+}
+/** Print the checks and return the exit code: 1 if any check failed. */
+function doctor(cwd = process.cwd()) {
+    const checks = runChecks(cwd);
+    const marks = { ok: log_1.icon.success, warn: log_1.icon.warn, fail: log_1.icon.error };
+    for (const check of checks) {
+        console.log(`${marks[check.status]} ${check.name.padEnd(24)}${log_1.c.dim(check.detail)}`);
+    }
+    const failed = checks.filter((x) => x.status === "fail").length;
+    const warned = checks.filter((x) => x.status === "warn").length;
+    console.log();
+    if (failed)
+        console.log(log_1.c.red(`${failed} check(s) failed${warned ? `, ${warned} warning(s)` : ""}.`));
+    else
+        console.log(log_1.c.green(`All checks passed${warned ? ` with ${warned} warning(s)` : ""}.`));
+    return failed ? 1 : 0;
+}

package/dist/commands/new.d.ts

@@ -0,0 +1,19 @@
+export declare const PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare const FEATURES: readonly ["openapi", "cors", "typeorm", "knex", "scalar"];
+export type Feature = (typeof FEATURES)[number];
+export type NewOptions = {
+    cwd?: string;
+    minimal?: boolean;
+    force?: boolean;
+    /** Skip prompts and use defaults for anything not given. */
+    yes?: boolean;
+    pm?: string;
+    features?: string[];
+    /** Skip `<pm> install`. Also enabled by the `AVLEON_SKIP_INSTALL=1` environment variable. */
+    skipInstall?: boolean;
+};
+export declare function packageJson(name: string, features: Feature[], minimal: boolean): string;
+export declare function installCommand(pm: PackageManager): string;
+export declare function devCommand(pm: PackageManager): string;
+export declare function createApplication(name: string, opts?: NewOptions): Promise<string>;

package/dist/commands/new.js

@@ -0,0 +1,306 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURES = exports.PACKAGE_MANAGERS = void 0;
+exports.packageJson = packageJson;
+exports.installCommand = installCommand;
+exports.devCommand = devCommand;
+exports.createApplication = createApplication;
+const child_process_1 = require("child_process");
+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 stubs_1 = require("../utils/stubs");
+const env_types_1 = require("../utils/env-types");
+exports.PACKAGE_MANAGERS = ["npm", "yarn", "pnpm"];
+exports.FEATURES = ["openapi", "cors", "typeorm", "knex", "scalar"];
+const DEFAULT_FEATURES = ["openapi"];
+/** Third-party versions for generated projects. */
+const DEP_VERSIONS = {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.2",
+    "reflect-metadata": "^0.2.2",
+    "@fastify/cors": "^11.0.0",
+    typeorm: "^0.3.20",
+    pg: "^8.11.0",
+    knex: "^3.1.0",
+    "@scalar/fastify-api-reference": "^1.0.0",
+    typescript: "^5.7.2",
+    "@types/node": "^22.9.3",
+    vitest: "^4.1.12",
+    "@vitest/coverage-v8": "^4.1.12",
+    "unplugin-swc": "^2.0.0",
+    "@swc/core": "^1.16.20",
+};
+function isDirEmpty(dir) {
+    return fs_1.default.readdirSync(dir).length === 0;
+}
+function validateFeatures(features) {
+    const unknown = features.filter((f) => !exports.FEATURES.includes(f));
+    if (unknown.length) {
+        throw new errors_1.CliError(`Unknown feature(s): ${unknown.join(", ")}. Choose from: ${exports.FEATURES.join(", ")}.`);
+    }
+    return features;
+}
+async function prompt(opts) {
+    if (opts.pm && !exports.PACKAGE_MANAGERS.includes(opts.pm)) {
+        throw new errors_1.CliError(`Unknown package manager "${opts.pm}". Choose from: ${exports.PACKAGE_MANAGERS.join(", ")}.`);
+    }
+    const interactive = !opts.yes && process.stdin.isTTY === true && process.stdout.isTTY === true;
+    let pm = opts.pm;
+    let features = opts.features ? validateFeatures(opts.features) : undefined;
+    if (opts.minimal)
+        features = [];
+    if (interactive && (!pm || !features)) {
+        const { default: inquirer } = await Promise.resolve().then(() => __importStar(require("inquirer")));
+        if (!pm) {
+            ({ pm } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "pm",
+                    message: "Package manager:",
+                    choices: [...exports.PACKAGE_MANAGERS],
+                    default: "npm",
+                },
+            ]));
+        }
+        if (!features) {
+            ({ features } = await inquirer.prompt([
+                {
+                    type: "checkbox",
+                    name: "features",
+                    message: "Select features to include:",
+                    choices: [
+                        { name: "OpenAPI / Swagger docs", value: "openapi", checked: true },
+                        { name: "CORS support", value: "cors" },
+                        { name: "TypeORM", value: "typeorm" },
+                        { name: "Knex", value: "knex" },
+                        { name: "Scalar UI (replaces Swagger UI)", value: "scalar" },
+                    ],
+                },
+            ]));
+        }
+    }
+    return { pm: pm ?? "npm", features: features ?? DEFAULT_FEATURES };
+}
+function packageJson(name, features, minimal) {
+    const v = (0, stubs_1.cliVersion)();
+    const deps = {
+        "@avleon/core": (0, stubs_1.coreRange)(),
+        "@avleon/cli": `^${v}`,
+    };
+    const pick = (...names) => names.forEach((n) => (deps[n] = DEP_VERSIONS[n]));
+    pick("class-transformer", "class-validator", "reflect-metadata");
+    if (features.includes("cors"))
+        pick("@fastify/cors");
+    if (usesData(features))
+        deps["@avleon/data"] = `^${v}`;
+    if (features.includes("typeorm"))
+        pick("typeorm", "pg");
+    if (features.includes("knex"))
+        pick("knex", "pg");
+    if (features.includes("scalar"))
+        pick("@scalar/fastify-api-reference");
+    const devDeps = {};
+    const pickDev = (...names) => names.forEach((n) => (devDeps[n] = DEP_VERSIONS[n]));
+    pickDev("@types/node", "typescript");
+    if (!minimal)
+        pickDev("@swc/core", "@vitest/coverage-v8", "unplugin-swc", "vitest");
+    const scripts = {
+        "start:dev": "avleon serve",
+        build: "avleon build",
+        start: "avleon start",
+    };
+    if (!minimal) {
+        Object.assign(scripts, {
+            test: "vitest run",
+            "test:watch": "vitest",
+            "test:cov": "vitest run --coverage",
+            "test:e2e": "vitest run --config vitest.e2e.config.mts",
+        });
+    }
+    const pkg = {
+        name: (0, names_1.kebabCase)(name) || "avleon-app",
+        version: "0.0.1",
+        private: true,
+        description: `${(0, names_1.titleCase)(name)} API built with Avleon`,
+        main: "dist/serve.js",
+        scripts,
+        keywords: ["avleon", "nodejs", "typescript"],
+        engines: { node: ">=20" },
+        dependencies: sortKeys(deps),
+        devDependencies: sortKeys(devDeps),
+    };
+    return JSON.stringify(pkg, null, 2) + "\n";
+}
+/** TypeORM and Knex come from the @avleon/data plugin. */
+function usesData(features) {
+    return features.includes("typeorm") || features.includes("knex");
+}
+function sortKeys(obj) {
+    return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
+function appSource(features) {
+    const imports = [];
+    const setup = [];
+    if (features.includes("openapi") || features.includes("scalar")) {
+        imports.push(`import { OpenApiConfig } from './config/openapi.config';`);
+    }
+    if (features.includes("cors"))
+        setup.push(`app.useCors({ origin: '*' });`);
+    if (imports.length)
+        setup.push(`if (app.isDevelopment()) {\n  app.useOpenApi(OpenApiConfig);\n}`);
+    if (features.includes("typeorm")) {
+        setup.push(`// TODO: pass your TypeORM DataSourceOptions (or an @AppConfig class)\n` +
+            `// await app.useTypeORM({ type: 'postgres', url: process.env.DATABASE_URL, entities: [] });`);
+    }
+    if (features.includes("knex")) {
+        setup.push(`// TODO: pass your Knex config (or an @AppConfig class)\n` +
+            `// await app.useKnex({ client: 'pg', connection: process.env.DATABASE_URL });`);
+    }
+    return (0, stubs_1.renderStub)("project/app.stub", {
+        Imports: imports.map((i) => i + "\n").join(""),
+        Setup: setup.map((s) => "\n" + s + "\n").join(""),
+    });
+}
+function installCommand(pm) {
+    return `${pm} install`;
+}
+function devCommand(pm) {
+    return pm === "npm" ? "npm run start:dev" : `${pm} start:dev`;
+}
+function runInstall(pm, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(pm, ["install"], { cwd, stdio: "inherit", shell: process.platform === "win32" });
+        child.on("error", reject);
+        child.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(`${pm} install exited with code ${code}`))));
+    });
+}
+async function createApplication(name, opts = {}) {
+    if (!name || !name.trim())
+        throw new errors_1.CliError("Please provide a project name, e.g. `avleon new my-api`.");
+    const cwd = opts.cwd ?? process.cwd();
+    const root = path_1.default.resolve(cwd, name);
+    const appName = path_1.default.basename(root);
+    const minimal = !!opts.minimal;
+    if (fs_1.default.existsSync(root)) {
+        if (!fs_1.default.statSync(root).isDirectory())
+            throw new errors_1.CliError(`${root} exists and is not a directory.`);
+        if (!isDirEmpty(root) && !opts.force) {
+            throw new errors_1.CliError(`Directory ${root} is not empty. Use -f or --force to scaffold into it anyway.`);
+        }
+    }
+    const { pm, features } = await prompt(opts);
+    console.log();
+    console.log(log_1.c.bold(log_1.c.cyan("  Avleon")) + log_1.c.dim(` v${(0, stubs_1.cliVersion)()}`));
+    console.log(`  ${log_1.c.dim("Creating project:")} ${log_1.c.bold(appName)}${minimal ? log_1.c.dim(" (minimal)") : ""}`);
+    const rel = (f) => path_1.default.relative(cwd, f) || ".";
+    const files = [];
+    const add = (file, content) => files.push([path_1.default.join(root, file), content]);
+    if (minimal) {
+        add("src/app.ts", (0, stubs_1.renderStub)("project/app-minimal.stub"));
+    }
+    else {
+        add("src/services/home.service.ts", (0, stubs_1.renderStub)("project/home.service.stub"));
+        add("src/controllers/home.controller.ts", (0, stubs_1.renderStub)("project/home.controller.stub"));
+        add("src/controllers/home.controller.spec.ts", (0, stubs_1.renderStub)("project/home.controller.spec.stub"));
+        if (features.includes("openapi") || features.includes("scalar")) {
+            add("src/config/openapi.config.ts", (0, stubs_1.renderStub)("project/openapi.config.stub", {
+                AppTitle: (0, names_1.titleCase)(appName) || appName,
+                Provider: features.includes("scalar") ? "\n      provider: 'scalar'," : "",
+            }));
+        }
+        add("src/app.ts", appSource(features));
+        add("vitest.config.mts", (0, stubs_1.renderStub)("project/vitest.config.stub"));
+        add("vitest.e2e.config.mts", (0, stubs_1.renderStub)("project/vitest-e2e.config.stub"));
+    }
+    add("src/serve.ts", (0, stubs_1.renderStub)("project/serve.stub"));
+    add("package.json", packageJson(appName, features, minimal));
+    add("tsconfig.json", (0, stubs_1.renderStub)("project/tsconfig.stub"));
+    add(env_types_1.ENV_TYPES_FILE, (0, env_types_1.envTypesFile)(usesData(features) ? ["@avleon/data"] : []));
+    add("tsconfig.build.json", (0, stubs_1.renderStub)("project/tsconfig.build.stub"));
+    add(".gitignore", (0, stubs_1.renderStub)("project/gitignore.stub"));
+    add(".env", (0, stubs_1.renderStub)("project/env.stub"));
+    add("README.md", (0, stubs_1.renderStub)("project/readme.stub", {
+        AppTitle: (0, names_1.titleCase)(appName) || appName,
+        InstallCmd: installCommand(pm),
+        DevCmd: devCommand(pm),
+        TestRow: minimal ? "" : "| `test`      | Run unit tests |\n",
+        Tree: minimal
+            ? ""
+            : "├── controllers/   # Route controllers\n├── services/      # Business logic\n├── config/        # App configuration\n",
+    }));
+    log_1.log.section("Generating files");
+    for (const [file, content] of files) {
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, content, "utf8");
+        log_1.log.step(path_1.default.relative(root, file).split(path_1.default.sep).join("/"), "");
+    }
+    if (!minimal)
+        fs_1.default.mkdirSync(path_1.default.join(root, "public"), { recursive: true });
+    const skipInstall = opts.skipInstall || process.env.AVLEON_SKIP_INSTALL === "1";
+    if (skipInstall) {
+        log_1.log.section("Skipping dependency install");
+    }
+    else {
+        log_1.log.section(`Installing dependencies (${pm})`);
+        try {
+            await runInstall(pm, root);
+            log_1.log.success("Dependencies installed");
+        }
+        catch (err) {
+            log_1.log.error(`Install failed: ${err instanceof Error ? err.message : err}`);
+            log_1.log.info(`  Run it manually: cd ${rel(root)} && ${installCommand(pm)}`);
+        }
+    }
+    console.log();
+    log_1.log.success(log_1.c.green("Project created."));
+    console.log(`\n  ${log_1.c.dim("Next steps:")}`);
+    if (rel(root) !== ".")
+        console.log(log_1.c.cyan(`    cd ${rel(root)}`));
+    if (skipInstall)
+        console.log(log_1.c.cyan(`    ${installCommand(pm)}`));
+    console.log(log_1.c.cyan(`    ${devCommand(pm)}`));
+    if (features.includes("openapi") || features.includes("scalar")) {
+        console.log(`\n  ${log_1.c.dim("API docs:")} http://localhost:4000/docs`);
+    }
+    console.log();
+    return root;
+}

package/dist/commands/route-list.d.ts

@@ -0,0 +1,19 @@
+export type Route = {
+    method: string;
+    path: string;
+    controller: string;
+    handler: string;
+    file: string;
+};
+export type RouteListOptions = {
+    cwd?: string;
+    json?: boolean;
+    static?: boolean;
+};
+export declare function joinRoute(...parts: string[]): string;
+export declare function runtimeRoutes(root: string): Route[];
+/** Scan `@ApiController` classes and their `@Get`/`@Post`/... methods without running any code. */
+export declare function scanRoutes(source: string, file: string): Route[];
+export declare function staticRoutes(root: string): Route[];
+export declare function formatRoutes(routes: Route[]): string;
+export declare function routeList(opts?: RouteListOptions): Route[];