@nage-api/cli 1.0.0-beta.2

package/dist/fs/file-tree.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The set of files a command intends to write, and the transaction that writes
+ * them (PLAN.md §10.5 — "atomically").
+ *
+ * Commands build a `FileTree` and hand it to `commitFileTree`, which writes
+ * everything or nothing. A half-created app — registered in the manifest but
+ * missing its module, or vice versa — is worse than a failed command, because
+ * the next command starts from an inconsistent workspace.
+ */
+export interface PlannedFile {
+    /** Path relative to the workspace root. */
+    readonly path: string;
+    readonly contents: string;
+    /**
+     * What to do when the file already exists.
+     * - `error` (default): the command fails; nothing is written.
+     * - `skip`: leave the existing file — how a generator stays idempotent.
+     * - `overwrite`: replace it, for files the CLI owns outright.
+     */
+    readonly onConflict?: 'error' | 'skip' | 'overwrite';
+}
+/** An ordered, de-duplicated set of files to write. */
+export declare class FileTree {
+    #private;
+    add(file: PlannedFile): this;
+    addAll(files: readonly PlannedFile[]): this;
+    get files(): readonly PlannedFile[];
+    get paths(): readonly string[];
+    get size(): number;
+}
+export interface CommitOptions {
+    readonly root: string;
+    /** Report what would be written without touching the disk. */
+    readonly dryRun?: boolean;
+}
+export interface CommitResult {
+    readonly written: readonly string[];
+    readonly skipped: readonly string[];
+}
+/**
+ * Write a tree, all or nothing.
+ *
+ * Files that already exist are backed up before being replaced, and everything
+ * is rolled back if any write fails — so an interrupted `nage new app` leaves
+ * the workspace exactly as it was.
+ */
+export declare function commitFileTree(tree: FileTree, options: CommitOptions): Promise<CommitResult>;
+/**
+ * Join and verify the result stays under the root.
+ *
+ * A generated name reaches this function; `../../etc/passwd` must not be a way
+ * for one to escape the workspace.
+ */
+export declare function safeJoin(root: string, path: string): string;
+/** Move a directory aside instead of deleting it — used by `remove app`. */
+export declare function archiveDirectory(root: string, path: string): Promise<string>;
+//# sourceMappingURL=file-tree.d.ts.map

package/dist/fs/file-tree.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * The set of files a command intends to write, and the transaction that writes
+ * them (PLAN.md §10.5 — "atomically").
+ *
+ * Commands build a `FileTree` and hand it to `commitFileTree`, which writes
+ * everything or nothing. A half-created app — registered in the manifest but
+ * missing its module, or vice versa — is worse than a failed command, because
+ * the next command starts from an inconsistent workspace.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTree = void 0;
+exports.commitFileTree = commitFileTree;
+exports.safeJoin = safeJoin;
+exports.archiveDirectory = archiveDirectory;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const core_1 = require("@nage-api/core");
+/** An ordered, de-duplicated set of files to write. */
+class FileTree {
+    #files = new Map();
+    add(file) {
+        const normalised = file.path.split('\\').join('/');
+        const existing = this.#files.get(normalised);
+        if (existing !== undefined && existing.contents !== file.contents) {
+            throw new core_1.ConfigurationError({
+                detail: `Two different contents were planned for "${normalised}"`,
+                meta: { path: normalised },
+            });
+        }
+        this.#files.set(normalised, { ...file, path: normalised });
+        return this;
+    }
+    addAll(files) {
+        for (const file of files)
+            this.add(file);
+        return this;
+    }
+    get files() {
+        return [...this.#files.values()].sort((left, right) => left.path.localeCompare(right.path));
+    }
+    get paths() {
+        return this.files.map((file) => file.path);
+    }
+    get size() {
+        return this.#files.size;
+    }
+}
+exports.FileTree = FileTree;
+/**
+ * Write a tree, all or nothing.
+ *
+ * Files that already exist are backed up before being replaced, and everything
+ * is rolled back if any write fails — so an interrupted `nage new app` leaves
+ * the workspace exactly as it was.
+ */
+async function commitFileTree(tree, options) {
+    const root = (0, node_path_1.resolve)(options.root);
+    const written = [];
+    const skipped = [];
+    const created = [];
+    const backups = new Map();
+    // Refuse the whole batch before writing anything, rather than discovering a
+    // conflict half way through.
+    for (const file of tree.files) {
+        const absolute = safeJoin(root, file.path);
+        if (!(0, node_fs_1.existsSync)(absolute))
+            continue;
+        const policy = file.onConflict ?? 'error';
+        if (policy === 'error') {
+            throw new core_1.ConfigurationError({
+                detail: `"${file.path}" already exists; refusing to overwrite it`,
+                meta: { path: file.path, hint: 'Remove the file, or re-run with --force.' },
+            });
+        }
+        if (policy === 'skip')
+            skipped.push(file.path);
+    }
+    if (options.dryRun === true) {
+        return { written: tree.paths.filter((path) => !skipped.includes(path)), skipped };
+    }
+    try {
+        for (const file of tree.files) {
+            if (skipped.includes(file.path))
+                continue;
+            const absolute = safeJoin(root, file.path);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(absolute), { recursive: true });
+            if ((0, node_fs_1.existsSync)(absolute)) {
+                backups.set(absolute, await (0, promises_1.readFile)(absolute, 'utf8'));
+            }
+            else {
+                created.push(absolute);
+            }
+            await (0, promises_1.writeFile)(absolute, file.contents, 'utf8');
+            written.push(file.path);
+        }
+        return { written, skipped };
+    }
+    catch (error) {
+        await rollback(created, backups);
+        throw error;
+    }
+}
+async function rollback(created, backups) {
+    for (const path of created)
+        await (0, promises_1.rm)(path, { force: true });
+    for (const [path, contents] of backups)
+        await (0, promises_1.writeFile)(path, contents, 'utf8');
+}
+/**
+ * Join and verify the result stays under the root.
+ *
+ * A generated name reaches this function; `../../etc/passwd` must not be a way
+ * for one to escape the workspace.
+ */
+function safeJoin(root, path) {
+    const absolute = (0, node_path_1.resolve)((0, node_path_1.join)(root, path));
+    const relation = (0, node_path_1.relative)((0, node_path_1.resolve)(root), absolute);
+    if (relation.startsWith('..')) {
+        throw new core_1.ConfigurationError({
+            detail: `"${path}" resolves outside the workspace`,
+            meta: { path },
+        });
+    }
+    return absolute;
+}
+/** Move a directory aside instead of deleting it — used by `remove app`. */
+async function archiveDirectory(root, path) {
+    const source = safeJoin(root, path);
+    const destination = `${source}.removed`;
+    await (0, promises_1.rm)(destination, { recursive: true, force: true });
+    await (0, promises_1.rename)(source, destination);
+    return (0, node_path_1.relative)(root, destination);
+}
+//# sourceMappingURL=file-tree.js.map

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@nage-api/cli` — the scaffolding and workspace-management tool (PLAN.md §10).
+ *
+ * The package is a library first and an executable second: every command is a
+ * pure planning function returning the files it would write, and `bin/nage`
+ * (`main.ts`) is a thin process wrapper. That split is what makes the CLI
+ * testable without a subprocess, and reusable from an editor extension or a
+ * higher-level generator.
+ */
+export { run, usage, CLI_VERSION, type CliIo, type RunOptions } from './cli.js';
+export { deriveNames, pluralise, type Names } from './naming.js';
+export { FileTree, archiveDirectory, commitFileTree, safeJoin, type CommitOptions, type CommitResult, type PlannedFile, } from './fs/file-tree.js';
+export { MANIFEST_FILE, DEFAULT_PORT, createManifest, findWorkspaceRoot, loadWorkspace, nextAvailablePort, parseManifest, resolveTargetApp, serialiseManifest, type AppEntry, type FeatureName, type PackageEntry, type Preset, type WorkspaceManifest, } from './workspace/manifest.js';
+export { addPathAlias, addProjectReference, addTurboTaskOutput, addWorkspaceGlob, removePathAlias, removeProjectReference, } from './workspace/wiring.js';
+export { DEFAULT_FRAMEWORK_VERSION, planCreate, planNewApp, planNewPackage, type CommandPlan, type CreateOptions, type NewAppOptions, type NewPackageOptions, } from './commands/create.js';
+export { SCHEMATICS, planGenerate, type GenerateOptions, type GenerateResult, type Schematic, } from './commands/generate.js';
+export { FEATURES, formatInfo, formatList, planAddFeature, planRemoveApp, planRemoveFeature, planRemovePackage, selectApps, type FeatureChange, type FeatureOptions, type RemoveAppOptions, } from './commands/features.js';
+export { checkWorkspaceIntegrity, readDotEnv, runDoctor, type DoctorOptions, type DoctorReport, } from './commands/doctor.js';
+export { appFiles, featurePackage, isHttpPreset, type AppTemplateInput, } from './templates/app.template.js';
+export { compactTimestamp, parseFields, resourceFiles, type FieldSpec, type ResourceTemplateInput, } from './templates/resource.template.js';
+export { driverPackageFor, json, workspaceFiles, type WorkspaceTemplateInput, } from './templates/workspace.template.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * `@nage-api/cli` — the scaffolding and workspace-management tool (PLAN.md §10).
+ *
+ * The package is a library first and an executable second: every command is a
+ * pure planning function returning the files it would write, and `bin/nage`
+ * (`main.ts`) is a thin process wrapper. That split is what makes the CLI
+ * testable without a subprocess, and reusable from an editor extension or a
+ * higher-level generator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceFiles = exports.json = exports.driverPackageFor = exports.resourceFiles = exports.parseFields = exports.compactTimestamp = exports.isHttpPreset = exports.featurePackage = exports.appFiles = exports.runDoctor = exports.readDotEnv = exports.checkWorkspaceIntegrity = exports.selectApps = exports.planRemovePackage = exports.planRemoveFeature = exports.planRemoveApp = exports.planAddFeature = exports.formatList = exports.formatInfo = exports.FEATURES = exports.planGenerate = exports.SCHEMATICS = exports.planNewPackage = exports.planNewApp = exports.planCreate = exports.DEFAULT_FRAMEWORK_VERSION = exports.removeProjectReference = exports.removePathAlias = exports.addWorkspaceGlob = exports.addTurboTaskOutput = exports.addProjectReference = exports.addPathAlias = exports.serialiseManifest = exports.resolveTargetApp = exports.parseManifest = exports.nextAvailablePort = exports.loadWorkspace = exports.findWorkspaceRoot = exports.createManifest = exports.DEFAULT_PORT = exports.MANIFEST_FILE = exports.safeJoin = exports.commitFileTree = exports.archiveDirectory = exports.FileTree = exports.pluralise = exports.deriveNames = exports.CLI_VERSION = exports.usage = exports.run = void 0;
+var cli_js_1 = require("./cli.js");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return cli_js_1.run; } });
+Object.defineProperty(exports, "usage", { enumerable: true, get: function () { return cli_js_1.usage; } });
+Object.defineProperty(exports, "CLI_VERSION", { enumerable: true, get: function () { return cli_js_1.CLI_VERSION; } });
+// Naming — one word in, every casing out.
+var naming_js_1 = require("./naming.js");
+Object.defineProperty(exports, "deriveNames", { enumerable: true, get: function () { return naming_js_1.deriveNames; } });
+Object.defineProperty(exports, "pluralise", { enumerable: true, get: function () { return naming_js_1.pluralise; } });
+// The write transaction.
+var file_tree_js_1 = require("./fs/file-tree.js");
+Object.defineProperty(exports, "FileTree", { enumerable: true, get: function () { return file_tree_js_1.FileTree; } });
+Object.defineProperty(exports, "archiveDirectory", { enumerable: true, get: function () { return file_tree_js_1.archiveDirectory; } });
+Object.defineProperty(exports, "commitFileTree", { enumerable: true, get: function () { return file_tree_js_1.commitFileTree; } });
+Object.defineProperty(exports, "safeJoin", { enumerable: true, get: function () { return file_tree_js_1.safeJoin; } });
+// The workspace manifest and the files that must stay in step with it.
+var manifest_js_1 = require("./workspace/manifest.js");
+Object.defineProperty(exports, "MANIFEST_FILE", { enumerable: true, get: function () { return manifest_js_1.MANIFEST_FILE; } });
+Object.defineProperty(exports, "DEFAULT_PORT", { enumerable: true, get: function () { return manifest_js_1.DEFAULT_PORT; } });
+Object.defineProperty(exports, "createManifest", { enumerable: true, get: function () { return manifest_js_1.createManifest; } });
+Object.defineProperty(exports, "findWorkspaceRoot", { enumerable: true, get: function () { return manifest_js_1.findWorkspaceRoot; } });
+Object.defineProperty(exports, "loadWorkspace", { enumerable: true, get: function () { return manifest_js_1.loadWorkspace; } });
+Object.defineProperty(exports, "nextAvailablePort", { enumerable: true, get: function () { return manifest_js_1.nextAvailablePort; } });
+Object.defineProperty(exports, "parseManifest", { enumerable: true, get: function () { return manifest_js_1.parseManifest; } });
+Object.defineProperty(exports, "resolveTargetApp", { enumerable: true, get: function () { return manifest_js_1.resolveTargetApp; } });
+Object.defineProperty(exports, "serialiseManifest", { enumerable: true, get: function () { return manifest_js_1.serialiseManifest; } });
+var wiring_js_1 = require("./workspace/wiring.js");
+Object.defineProperty(exports, "addPathAlias", { enumerable: true, get: function () { return wiring_js_1.addPathAlias; } });
+Object.defineProperty(exports, "addProjectReference", { enumerable: true, get: function () { return wiring_js_1.addProjectReference; } });
+Object.defineProperty(exports, "addTurboTaskOutput", { enumerable: true, get: function () { return wiring_js_1.addTurboTaskOutput; } });
+Object.defineProperty(exports, "addWorkspaceGlob", { enumerable: true, get: function () { return wiring_js_1.addWorkspaceGlob; } });
+Object.defineProperty(exports, "removePathAlias", { enumerable: true, get: function () { return wiring_js_1.removePathAlias; } });
+Object.defineProperty(exports, "removeProjectReference", { enumerable: true, get: function () { return wiring_js_1.removeProjectReference; } });
+// Commands, as plans.
+var create_js_1 = require("./commands/create.js");
+Object.defineProperty(exports, "DEFAULT_FRAMEWORK_VERSION", { enumerable: true, get: function () { return create_js_1.DEFAULT_FRAMEWORK_VERSION; } });
+Object.defineProperty(exports, "planCreate", { enumerable: true, get: function () { return create_js_1.planCreate; } });
+Object.defineProperty(exports, "planNewApp", { enumerable: true, get: function () { return create_js_1.planNewApp; } });
+Object.defineProperty(exports, "planNewPackage", { enumerable: true, get: function () { return create_js_1.planNewPackage; } });
+var generate_js_1 = require("./commands/generate.js");
+Object.defineProperty(exports, "SCHEMATICS", { enumerable: true, get: function () { return generate_js_1.SCHEMATICS; } });
+Object.defineProperty(exports, "planGenerate", { enumerable: true, get: function () { return generate_js_1.planGenerate; } });
+var features_js_1 = require("./commands/features.js");
+Object.defineProperty(exports, "FEATURES", { enumerable: true, get: function () { return features_js_1.FEATURES; } });
+Object.defineProperty(exports, "formatInfo", { enumerable: true, get: function () { return features_js_1.formatInfo; } });
+Object.defineProperty(exports, "formatList", { enumerable: true, get: function () { return features_js_1.formatList; } });
+Object.defineProperty(exports, "planAddFeature", { enumerable: true, get: function () { return features_js_1.planAddFeature; } });
+Object.defineProperty(exports, "planRemoveApp", { enumerable: true, get: function () { return features_js_1.planRemoveApp; } });
+Object.defineProperty(exports, "planRemoveFeature", { enumerable: true, get: function () { return features_js_1.planRemoveFeature; } });
+Object.defineProperty(exports, "planRemovePackage", { enumerable: true, get: function () { return features_js_1.planRemovePackage; } });
+Object.defineProperty(exports, "selectApps", { enumerable: true, get: function () { return features_js_1.selectApps; } });
+var doctor_js_1 = require("./commands/doctor.js");
+Object.defineProperty(exports, "checkWorkspaceIntegrity", { enumerable: true, get: function () { return doctor_js_1.checkWorkspaceIntegrity; } });
+Object.defineProperty(exports, "readDotEnv", { enumerable: true, get: function () { return doctor_js_1.readDotEnv; } });
+Object.defineProperty(exports, "runDoctor", { enumerable: true, get: function () { return doctor_js_1.runDoctor; } });
+// Templates, so a project can generate the same files from its own tooling.
+var app_template_js_1 = require("./templates/app.template.js");
+Object.defineProperty(exports, "appFiles", { enumerable: true, get: function () { return app_template_js_1.appFiles; } });
+Object.defineProperty(exports, "featurePackage", { enumerable: true, get: function () { return app_template_js_1.featurePackage; } });
+Object.defineProperty(exports, "isHttpPreset", { enumerable: true, get: function () { return app_template_js_1.isHttpPreset; } });
+var resource_template_js_1 = require("./templates/resource.template.js");
+Object.defineProperty(exports, "compactTimestamp", { enumerable: true, get: function () { return resource_template_js_1.compactTimestamp; } });
+Object.defineProperty(exports, "parseFields", { enumerable: true, get: function () { return resource_template_js_1.parseFields; } });
+Object.defineProperty(exports, "resourceFiles", { enumerable: true, get: function () { return resource_template_js_1.resourceFiles; } });
+var workspace_template_js_1 = require("./templates/workspace.template.js");
+Object.defineProperty(exports, "driverPackageFor", { enumerable: true, get: function () { return workspace_template_js_1.driverPackageFor; } });
+Object.defineProperty(exports, "json", { enumerable: true, get: function () { return workspace_template_js_1.json; } });
+Object.defineProperty(exports, "workspaceFiles", { enumerable: true, get: function () { return workspace_template_js_1.workspaceFiles; } });
+//# sourceMappingURL=index.js.map

package/dist/main.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * The `nage` executable.
+ *
+ * This file is the only place in the package that reads `process` or sets an
+ * exit code: it turns the process environment into `RunOptions` and the
+ * returned code into `process.exitCode`. Everything else is a function a test
+ * can call directly.
+ */
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * The `nage` executable.
+ *
+ * This file is the only place in the package that reads `process` or sets an
+ * exit code: it turns the process environment into `RunOptions` and the
+ * returned code into `process.exitCode`. Everything else is a function a test
+ * can call directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cli_js_1 = require("./cli.js");
+(0, cli_js_1.run)({
+    argv: process.argv.slice(2),
+    cwd: process.cwd(),
+    version: readVersion(),
+    io: {
+        out: (message) => void process.stdout.write(message),
+        err: (message) => void process.stderr.write(message),
+    },
+})
+    .then((code) => {
+    // Setting `exitCode` rather than calling `exit()` lets buffered stdout
+    // flush; `process.exit()` truncates piped output.
+    process.exitCode = code;
+})
+    .catch((error) => {
+    process.stderr.write(`✖ ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+    process.exitCode = 1;
+});
+/** The installed version, so `nage info` and bug reports agree with npm. */
+function readVersion() {
+    try {
+        const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '..', 'package.json'), 'utf8'));
+        return manifest.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/naming.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Name derivation for generators (PLAN.md §10.3).
+ *
+ * A developer types `nage g resource product` once; from that single word the
+ * generator needs a class name, a file stem, a route, a table and a variable.
+ * Deriving them in one place is what keeps `ProductModule`, `product.module.ts`
+ * and `/products` consistent across every emitted file.
+ */
+/** Every casing of one name. */
+export interface Names {
+    /** As typed, normalised: `product-category`. */
+    readonly kebab: string;
+    /** `ProductCategory` — class names. */
+    readonly pascal: string;
+    /** `productCategory` — variables and properties. */
+    readonly camel: string;
+    /** `product_category` — columns and tables. */
+    readonly snake: string;
+    /** `product-categories` — route segments. */
+    readonly pluralKebab: string;
+    /** `product_categories` — table names. */
+    readonly pluralSnake: string;
+    /** `Product category` — human-readable, for docs and messages. */
+    readonly title: string;
+}
+/**
+ * Naive English pluralisation.
+ *
+ * Deliberately naive: it covers the cases a resource name actually hits, and a
+ * wrong guess is fixed by `--route`. Pulling in an inflection library to get
+ * `octopus` right is not worth the dependency.
+ */
+export declare function pluralise(word: string): string;
+/** Derive every casing of `name`, or reject it with a readable reason. */
+export declare function deriveNames(name: string): Names;
+//# sourceMappingURL=naming.d.ts.map

package/dist/naming.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Name derivation for generators (PLAN.md §10.3).
+ *
+ * A developer types `nage g resource product` once; from that single word the
+ * generator needs a class name, a file stem, a route, a table and a variable.
+ * Deriving them in one place is what keeps `ProductModule`, `product.module.ts`
+ * and `/products` consistent across every emitted file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluralise = pluralise;
+exports.deriveNames = deriveNames;
+const core_1 = require("@nage-api/core");
+/** Names must be usable as identifiers, file names and URL segments. */
+const VALID_NAME = /^[a-z][a-z0-9]*(?:[-_ ]?[a-zA-Z0-9]+)*$/;
+/** Reserved because they collide with framework or workspace directories. */
+const RESERVED = new Set(['node_modules', 'dist', 'src', 'test', 'apps', 'packages', 'database']);
+function words(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .split(/[-_\s]+/)
+        .filter((word) => word.length > 0)
+        .map((word) => word.toLowerCase());
+}
+/**
+ * Naive English pluralisation.
+ *
+ * Deliberately naive: it covers the cases a resource name actually hits, and a
+ * wrong guess is fixed by `--route`. Pulling in an inflection library to get
+ * `octopus` right is not worth the dependency.
+ */
+function pluralise(word) {
+    if (/(?:s|x|z|ch|sh)$/.test(word))
+        return `${word}es`;
+    if (/[^aeiou]y$/.test(word))
+        return `${word.slice(0, -1)}ies`;
+    return `${word}s`;
+}
+/** Derive every casing of `name`, or reject it with a readable reason. */
+function deriveNames(name) {
+    const trimmed = name.trim();
+    if (!VALID_NAME.test(trimmed)) {
+        throw new core_1.ConfigurationError({
+            detail: `"${name}" is not a usable name. Start with a lowercase letter and use ` +
+                `letters, digits, hyphens or underscores — it becomes a class name, a ` +
+                `file name and a URL segment.`,
+            meta: { name },
+        });
+    }
+    if (RESERVED.has(trimmed)) {
+        throw new core_1.ConfigurationError({
+            detail: `"${trimmed}" is reserved; it would collide with a workspace directory.`,
+            meta: { name: trimmed },
+        });
+    }
+    const parts = words(trimmed);
+    const last = parts[parts.length - 1] ?? trimmed;
+    const plural = [...parts.slice(0, -1), pluralise(last)];
+    return {
+        kebab: parts.join('-'),
+        pascal: parts.map(capitalise).join(''),
+        camel: parts.map((word, index) => (index === 0 ? word : capitalise(word))).join(''),
+        snake: parts.join('_'),
+        pluralKebab: plural.join('-'),
+        pluralSnake: plural.join('_'),
+        title: capitalise(parts.join(' ')),
+    };
+}
+function capitalise(word) {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+}
+//# sourceMappingURL=naming.js.map

package/dist/templates/app.template.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Files for one application (PLAN.md §9.1, §10.2).
+ *
+ * Four presets, one shape: a thin `main.ts` that calls `bootstrap`, a typed
+ * `nage.config.ts`, a zod env schema, health endpoints and a Dockerfile. What
+ * differs between presets is which modules are imported and whether an HTTP
+ * server is started at all.
+ */
+import type { PlannedFile } from '../fs/file-tree.js';
+import type { AppEntry, FeatureName, Preset, WorkspaceManifest } from '../workspace/manifest.js';
+export interface AppTemplateInput {
+    readonly app: AppEntry;
+    readonly manifest: WorkspaceManifest;
+}
+export declare function featurePackage(feature: FeatureName): string;
+/** A worker has no HTTP surface, so it neither binds a port nor gets CORS. */
+export declare function isHttpPreset(preset: Preset): boolean;
+export declare function appFiles(input: AppTemplateInput): PlannedFile[];
+//# sourceMappingURL=app.template.d.ts.map