create-veap 0.1.2

package/dist/package-manager.js

@@ -0,0 +1,222 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+export const PACKAGE_MANAGERS = [
+    "pnpm",
+    "npm",
+    "yarn",
+    "bun",
+];
+/** Versions pinned into the generated project's `packageManager` field. */
+const PINNED_VERSIONS = {
+    pnpm: "11.9.0",
+    yarn: "4.9.2",
+};
+const LOCKFILES = [
+    { file: "pnpm-lock.yaml", pm: "pnpm" },
+    { file: "bun.lock", pm: "bun" },
+    { file: "bun.lockb", pm: "bun" },
+    { file: "yarn.lock", pm: "yarn" },
+    { file: "package-lock.json", pm: "npm" },
+];
+const isPackageManager = (value) => PACKAGE_MANAGERS.includes(value);
+/**
+ * Detects the package manager to default to by inspecting `dir` (usually the
+ * directory the scaffolding command was launched from).
+ *
+ * Priority: `packageManager` field in package.json > lockfiles > default (pnpm).
+ */
+export function detectPackageManager(dir) {
+    // 1. Explicit intent: packageManager field (corepack convention)
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            if (typeof pkg.packageManager === "string") {
+                // Handles both "pnpm@11.9.0" and "pnpm@https://..." forms
+                const name = pkg.packageManager.slice(0, pkg.packageManager.indexOf("@"));
+                if (isPackageManager(name)) {
+                    return { pm: name, source: "field", detail: pkg.packageManager };
+                }
+            }
+        }
+        catch {
+            // malformed package.json - fall through to lockfiles
+        }
+    }
+    // 2. Lockfiles
+    const found = LOCKFILES.filter((l) => fs.existsSync(path.join(dir, l.file)));
+    if (found.length > 1) {
+        // Ambiguous project (e.g. repo migrated between managers) - prefer pnpm,
+        // the framework default, and surface the conflict in the detail.
+        return {
+            pm: "pnpm",
+            source: "lockfile",
+            detail: `multiple lockfiles found: ${found
+                .map((l) => l.file)
+                .join(", ")}`,
+        };
+    }
+    if (found.length === 1) {
+        return { pm: found[0].pm, source: "lockfile", detail: found[0].file };
+    }
+    // 3. Framework default
+    return { pm: "pnpm", source: "default" };
+}
+function formatDetection(d) {
+    const origin = d.source === "field"
+        ? `packageManager field (${d.detail})`
+        : d.source === "lockfile"
+            ? d.detail
+            : "no lockfile found";
+    return `📦 Package manager detected: ${d.pm} (${origin})`;
+}
+/**
+ * Interactive numbered-choice prompt rendered on readline (no external
+ * prompt library, matching the rest of this CLI).
+ *
+ * The detected package manager is listed first as the default; pressing
+ * Enter accepts it. Accepts a number (1-4) or a name (`pnpm`, `npm`,
+ * `yarn`, `bun`). On EOF / closed stdin (piped input, CI) resolves to the
+ * detected default instead of hanging.
+ */
+export async function promptPackageManager(detection) {
+    console.log(formatDetection(detection));
+    console.log("\n? Which package manager should the project use?");
+    PACKAGE_MANAGERS.forEach((pm, i) => {
+        const suffix = pm === detection.pm && detection.source === "lockfile"
+            ? "  (detected - press Enter)"
+            : pm === detection.pm && detection.source === "field"
+                ? "  (from packageManager - press Enter)"
+                : "";
+        console.log(`  ${i + 1}) ${pm}${suffix}`);
+    });
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (pm) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(pm);
+            rl.close();
+        };
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on("close", () => {
+            // stdin exhausted (e.g. `echo "" | veap init ...`) - fall back to default
+            if (!settled) {
+                console.log(`\n⚠ Input closed - using ${detection.pm}`);
+                finish(detection.pm);
+            }
+        });
+        const ask = () => {
+            if (settled)
+                return;
+            rl.question("Choose [1]: ", (input) => {
+                const value = input.trim().toLowerCase();
+                if (value === "") {
+                    finish(detection.pm);
+                    return;
+                }
+                const asNumber = Number.parseInt(value, 10);
+                if (String(asNumber) === value &&
+                    asNumber >= 1 &&
+                    asNumber <= PACKAGE_MANAGERS.length) {
+                    finish(PACKAGE_MANAGERS[asNumber - 1]);
+                    return;
+                }
+                if (isPackageManager(value)) {
+                    finish(value);
+                    return;
+                }
+                console.log(`⚠ Unknown option "${input.trim()}" - enter 1-${PACKAGE_MANAGERS.length} or a name (${PACKAGE_MANAGERS.join(", ")}).`);
+                ask();
+            });
+        };
+        ask();
+    });
+}
+/**
+ * Resolves the package manager to use for a new project.
+ *
+ * Order: explicit `--pm <name>` flag (validated hard - scripts must not hang
+ * on a prompt) → interactive prompt (TTY only) → auto-detected default
+ * (non-TTY, CI).
+ */
+export async function resolvePackageManager(options) {
+    const detection = detectPackageManager(process.cwd());
+    if (options?.pm) {
+        const requested = options.pm.trim().toLowerCase();
+        if (isPackageManager(requested)) {
+            return requested;
+        }
+        console.error(`Error: Unknown package manager "${options.pm}". Allowed: ${PACKAGE_MANAGERS.join(", ")}.`);
+        process.exit(1);
+    }
+    if (!process.stdin.isTTY) {
+        console.log(`📦 Using ${detection.pm} (auto-detected${detection.detail ? `: ${detection.detail}` : ""})`);
+        return detection.pm;
+    }
+    return promptPackageManager(detection);
+}
+/**
+ * Applies the chosen package manager to the freshly scaffolded project:
+ *
+ * - pnpm: pins `packageManager` (corepack), writes `pnpm-workspace.yaml`
+ *   only when missing (an existing one is the source of truth)
+ * - yarn: pins `packageManager`, adds `.yarnrc.yml` with `nodeLinker:
+ *   node-modules` (berry's default PnP breaks Next.js)
+ * - npm/bun: removes `packageManager` (not managed by corepack), switches
+ *   workspace definition to the `workspaces` field in package.json
+ */
+export function applyPackageManager(projectDir, pm) {
+    const pkgPath = path.join(projectDir, "package.json");
+    if (!fs.existsSync(pkgPath))
+        return;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (pm === "pnpm" || pm === "yarn") {
+        pkg.packageManager = `${pm}@${PINNED_VERSIONS[pm]}`;
+    }
+    else {
+        delete pkg.packageManager;
+    }
+    const pnpmWorkspace = path.join(projectDir, "pnpm-workspace.yaml");
+    if (pm === "pnpm") {
+        // pnpm ignores the `workspaces` field and requires its own file (kept
+        // undefined in package.json to avoid a shadowing duplicate). Written
+        // only when missing - an existing one is the source of truth.
+        if (!fs.existsSync(pnpmWorkspace)) {
+            fs.writeFileSync(pnpmWorkspace, 'packages:\n  - "plugins/*"\n  - "templates/*"\n', "utf-8");
+        }
+    }
+    else {
+        pkg.workspaces = ["plugins/*", "templates/*"];
+        if (fs.existsSync(pnpmWorkspace)) {
+            // Switching away from pnpm: the file would shadow the workspaces field.
+            fs.rmSync(pnpmWorkspace);
+        }
+    }
+    fs.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
+    if (pm === "yarn") {
+        const yarnrc = [
+            "# Yarn Berry configuration generated by create-veap",
+            "nodeLinker: node-modules",
+            "",
+        ].join("\n");
+        fs.writeFileSync(path.join(projectDir, ".yarnrc.yml"), yarnrc, "utf-8");
+    }
+}
+/** Command prefix for a package-manager-agnostic npm-script invocation. */
+export function pmRunCommand(pm, script) {
+    return pm === "npm" ? `npm run ${script}` : `${pm} ${script}`;
+}
+/**
+ * Installs dependencies with the chosen package manager (all four use the
+ * same `install` verb).
+ */
+export function pmInstall(pm, cwd, opts) {
+    execSync(`${pm} install`, { cwd, stdio: opts?.stdio ?? "inherit" });
+}

package/dist/project-name.d.ts

@@ -0,0 +1,22 @@
+export interface ParsedProjectName {
+    /** npm scope without the leading `@`, or null for unscoped names. */
+    scope: string | null;
+    /** Package name inside the scope (equals the unscoped name otherwise). */
+    name: string;
+    /** Folder to create (base name for scoped packages). */
+    folder: string;
+    /** Full npm package name written into package.json. */
+    packageName: string;
+}
+/**
+ * Parses and validates a project name. Throws an `Error` with a readable
+ * message when the name violates npm package-name rules or hits a
+ * reserved scope/name.
+ */
+export declare function parseProjectName(input: string): ParsedProjectName;
+/**
+ * Full validation for user input: npm name rules (via `parseProjectName`)
+ * plus a filesystem collision check on the folder that would be created.
+ * Returns an error message, or null when the name is acceptable.
+ */
+export declare function projectNameError(input: string, cwd: string): string | null;

package/dist/project-name.js

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Project-name validation following npm package-name rules (the folder name
+ * becomes the package name via create-next-app):
+ *
+ * - lowercase only, max 214 characters
+ * - scoped names (`@scope/name`) are supported: the project folder receives
+ *   the base name, `package.json` the full scoped name
+ * - reserved scopes and names (the framework's own `@veap` namespace,
+ *   `next`, `react`, ...) are rejected
+ * - unscoped names must stay filesystem-safe (they become the folder)
+ */
+/** Scopes that may never be used for generated projects. */
+const RESERVED_SCOPES = [
+    "veap",
+    "next",
+    "react",
+    "vercel",
+    "npm",
+    "node",
+    "typescript",
+    "types",
+];
+/** Unscoped package names that may never be used for generated projects. */
+const RESERVED_NAMES = [
+    "veap",
+    "create-veap",
+    "create-next-app",
+    "next",
+    "react",
+    "react-dom",
+    "vercel",
+];
+const MAX_LENGTH = 214;
+function partError(part, label) {
+    if (part !== part.toLowerCase()) {
+        return `${label} must be lowercase (npm package name rules).`;
+    }
+    if (part.startsWith(".") || part.startsWith("_")) {
+        return `${label} cannot start with "." or "_".`;
+    }
+    if (part.length > MAX_LENGTH) {
+        return `${label} is too long (npm limit is ${MAX_LENGTH} characters).`;
+    }
+    return null;
+}
+/**
+ * Parses and validates a project name. Throws an `Error` with a readable
+ * message when the name violates npm package-name rules or hits a
+ * reserved scope/name.
+ */
+export function parseProjectName(input) {
+    const value = input.trim();
+    if (!value) {
+        throw new Error("Project name cannot be empty.");
+    }
+    if (value.startsWith("@")) {
+        const match = /^@([\w.-]+)\/([\w.-]+)$/.exec(value);
+        if (!match) {
+            throw new Error('Scoped names must look like "@scope/name" (lowercase letters, digits, ".", "_", "-").');
+        }
+        const scope = match[1];
+        const name = match[2];
+        const error = partError(scope, `Scope "${scope}"`) ?? partError(name, `Name "${name}"`);
+        if (error)
+            throw new Error(error);
+        if (RESERVED_SCOPES.includes(scope)) {
+            throw new Error(`The scope "@${scope}" is reserved and cannot be used for generated projects.`);
+        }
+        return {
+            scope,
+            name,
+            folder: name,
+            packageName: `@${scope}/${name}`,
+        };
+    }
+    // Unscoped: also becomes the folder, so keep it filesystem-safe.
+    if (!/^[a-z0-9][a-z0-9._-]*$/.test(value)) {
+        throw new Error('Use lowercase letters, digits, ".", "_" or "-" (must start with a letter or digit).');
+    }
+    const error = partError(value, "Project name");
+    if (error)
+        throw new Error(error);
+    if (RESERVED_NAMES.includes(value)) {
+        throw new Error(`The name "${value}" is reserved and cannot be used for generated projects.`);
+    }
+    return { scope: null, name: value, folder: value, packageName: value };
+}
+/**
+ * Full validation for user input: npm name rules (via `parseProjectName`)
+ * plus a filesystem collision check on the folder that would be created.
+ * Returns an error message, or null when the name is acceptable.
+ */
+export function projectNameError(input, cwd) {
+    let parsed;
+    try {
+        parsed = parseProjectName(input);
+    }
+    catch (err) {
+        return err.message;
+    }
+    if (fs.existsSync(path.resolve(cwd, parsed.folder))) {
+        return `Folder "${parsed.folder}" already exists in ${cwd}.`;
+    }
+    return null;
+}

package/dist/prompts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Interactive prompts for the scaffolder, following the same conventions as
+ * `promptPackageManager`: plain readline (no prompt library) and safe
+ * non-TTY behaviour - every prompt resolves to its default on EOF / closed
+ * stdin / non-interactive terminals, so CI never hangs.
+ *
+ * Validation (npm package-name rules, scoped names, reserved prefixes,
+ * folder collisions) lives in `project-name.ts`.
+ */
+/**
+ * Asks for a project name until a valid one is entered. Accepts scoped
+ * npm names (`@scope/name` - the folder becomes the base name). On EOF /
+ * non-TTY resolves to the default immediately.
+ */
+export declare function promptProjectName(defaultName: string, cwd: string): Promise<string>;
+/**
+ * Yes/no confirmation. Accepts y/yes/true (case-insensitive); empty input
+ * takes the default. On EOF / non-TTY resolves to the default.
+ */
+export declare function promptConfirm(question: string, defaultValue: boolean): Promise<boolean>;

package/dist/prompts.js

@@ -0,0 +1,93 @@
+import readline from "node:readline";
+import { projectNameError } from "./project-name.js";
+/**
+ * Interactive prompts for the scaffolder, following the same conventions as
+ * `promptPackageManager`: plain readline (no prompt library) and safe
+ * non-TTY behaviour - every prompt resolves to its default on EOF / closed
+ * stdin / non-interactive terminals, so CI never hangs.
+ *
+ * Validation (npm package-name rules, scoped names, reserved prefixes,
+ * folder collisions) lives in `project-name.ts`.
+ */
+/**
+ * Asks for a project name until a valid one is entered. Accepts scoped
+ * npm names (`@scope/name` - the folder becomes the base name). On EOF /
+ * non-TTY resolves to the default immediately.
+ */
+export function promptProjectName(defaultName, cwd) {
+    if (!process.stdin.isTTY) {
+        return Promise.resolve(defaultName);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (name) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(name);
+            rl.close();
+        };
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on("close", () => {
+            if (!settled) {
+                console.log(`\n⚠ Input closed - using "${defaultName}"`);
+                finish(defaultName);
+            }
+        });
+        const ask = () => {
+            if (settled)
+                return;
+            rl.question(`? Project name (npm name, e.g. \`@my-scope/my-app\`) [${defaultName}]: `, (input) => {
+                const value = input.trim() || defaultName;
+                const error = projectNameError(value, cwd);
+                if (error) {
+                    console.log(`⚠ ${error}`);
+                    ask();
+                    return;
+                }
+                finish(value);
+            });
+        };
+        ask();
+    });
+}
+/**
+ * Yes/no confirmation. Accepts y/yes/true (case-insensitive); empty input
+ * takes the default. On EOF / non-TTY resolves to the default.
+ */
+export function promptConfirm(question, defaultValue) {
+    if (!process.stdin.isTTY) {
+        return Promise.resolve(defaultValue);
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+            rl.close();
+        };
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on("close", () => {
+            if (!settled) {
+                finish(defaultValue);
+            }
+        });
+        const hint = defaultValue ? "[Y/n]" : "[y/N]";
+        rl.question(`? ${question} ${hint}: `, (input) => {
+            const value = input.trim().toLowerCase();
+            if (value === "") {
+                finish(defaultValue);
+                return;
+            }
+            finish(value === "y" || value === "yes" || value === "true");
+        });
+    });
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,26 @@
+import type { PackageManager } from "./package-manager.js";
+export interface ScaffoldOptions {
+    /** Directory in which the project folder is created. */
+    cwd: string;
+    pm: PackageManager;
+}
+/**
+ * Builds the explicit, non-interactive CNA invocation.
+ *
+ * Every choice is passed as a flag so CNA never prompts; `--yes` additionally
+ * absorbs flags introduced by future CNA versions (they resolve to defaults
+ * instead of hanging the scaffolder). `--skip-install` keeps a single
+ * dependency install at the end of `initProject`, after veap mutations.
+ */
+export declare function buildCreateNextAppCommand(name: string, opts: ScaffoldOptions): string;
+/**
+ * Normalizes a project name into a shell-safe, npm-friendly folder name.
+ * CNA derives the package name from the folder, so the same charset applies.
+ */
+export declare function sanitizeProjectName(name: string): string | null;
+/**
+ * Runs create-next-app. Throws (with the CNA output already streamed to the
+ * terminal) when scaffolding fails - CNA removes its own partial output.
+ * Returns the (possibly sanitized) project directory name.
+ */
+export declare function scaffoldNextApp(name: string, opts: ScaffoldOptions): string;

package/dist/scaffold.js

@@ -0,0 +1,62 @@
+import { execSync } from "node:child_process";
+/**
+ * Scaffolds the Next.js shell of a new project with the official
+ * `create-next-app` (CNA) instead of duplicating its boilerplate in stubs.
+ *
+ * Veap owns only the files CNA cannot know about (overlay, see
+ * `commands/init.ts`); everything else - Next version, tsconfig, postcss,
+ * fonts, README, git init - comes straight from CNA and stays current.
+ */
+/** How each package manager fetches and runs the CNA binary. */
+const CNA_RUNNERS = {
+    bun: "bun create next-app@latest",
+    pnpm: "pnpm dlx create-next-app@latest",
+    yarn: "yarn dlx create-next-app@latest",
+    npm: "npx --yes create-next-app@latest",
+};
+/**
+ * Builds the explicit, non-interactive CNA invocation.
+ *
+ * Every choice is passed as a flag so CNA never prompts; `--yes` additionally
+ * absorbs flags introduced by future CNA versions (they resolve to defaults
+ * instead of hanging the scaffolder). `--skip-install` keeps a single
+ * dependency install at the end of `initProject`, after veap mutations.
+ */
+export function buildCreateNextAppCommand(name, opts) {
+    const flags = [
+        "--ts",
+        "--tailwind",
+        "--app",
+        // ESLint is the veap linter: CNA writes eslint.config.mjs, the eslint
+        // dev deps and the `lint` script (kept as-is).
+        "--eslint",
+        "--react-compiler",
+        "--import-alias",
+        '"@/*"',
+        "--skip-install",
+    ];
+    return `${CNA_RUNNERS[opts.pm]} "${name}" ${flags.join(" ")}`;
+}
+/**
+ * Normalizes a project name into a shell-safe, npm-friendly folder name.
+ * CNA derives the package name from the folder, so the same charset applies.
+ */
+export function sanitizeProjectName(name) {
+    const safe = name.replace(/[^\w.-]/g, "-");
+    return safe === name ? null : safe;
+}
+/**
+ * Runs create-next-app. Throws (with the CNA output already streamed to the
+ * terminal) when scaffolding fails - CNA removes its own partial output.
+ * Returns the (possibly sanitized) project directory name.
+ */
+export function scaffoldNextApp(name, opts) {
+    const sanitized = sanitizeProjectName(name);
+    if (sanitized) {
+        console.log(`⚠ Project name sanitized: "${name}" → "${sanitized}"`);
+    }
+    const projectName = sanitized ?? name;
+    const command = buildCreateNextAppCommand(projectName, opts);
+    execSync(command, { cwd: opts.cwd, stdio: "inherit" });
+    return projectName;
+}

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function processStubs(srcDir: string, destDir: string, variables: Record<string, string>): void;

package/dist/utils.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+export function processStubs(srcDir, destDir, variables) {
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        let destName = entry.name;
+        for (const [key, value] of Object.entries(variables)) {
+            destName = destName.replace(new RegExp("\\{\\{" + key + "\\}\\}", "g"), value);
+        }
+        if (destName.endsWith(".stub")) {
+            destName = destName.slice(0, -5);
+        }
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, destName);
+        if (entry.isDirectory()) {
+            processStubs(srcPath, destPath, variables);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, "utf-8");
+            for (const [key, value] of Object.entries(variables)) {
+                content = content.replace(new RegExp("\\{\\{" + key + "\\}\\}", "g"), value);
+            }
+            fs.writeFileSync(destPath, content);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "create-veap",
+  "version": "0.1.2",
+  "description": "Initializer for Veap Framework applications",
+  "bugs": "https://github.com/veapjs/create-veap/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/veapjs/create-veap.git"
+  },
+  "type": "module",
+  "main": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "bin": {
+    "create-veap": "./bin/veap.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "stubs",
+    ".docs"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "rimraf dist && tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "ora": "^9.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.2",
+    "rimraf": "^6.1.3",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  }
+}

package/stubs/docker/.dockerignore.stub

@@ -0,0 +1,39 @@
+node_modules/
+.pnpm-store/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+.next/
+out/
+dist/
+build/
+.vercel/
+
+coverage/
+*.test.*
+*.spec.*
+
+.git/
+.gitignore
+.vscode/
+.idea/
+*.swp
+*.log
+
+.env
+.env*.local
+
+Dockerfile*
+.dockerignore
+compose.yaml
+compose.yml
+
+*.md
+docs/
+
+.turbo/
+.tmp/
+.temp/
+.DS_Store