genrex 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,148 @@
-# Temporary Holding Version
+# genrex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<p align="center">
+  <img src="https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white" alt="TypeScript" />
+  <img src="https://img.shields.io/badge/Node.js-339933?style=for-the-badge&logo=node.js&logoColor=white" alt="Node.js" />
+  <img src="https://img.shields.io/badge/Biome-60A5FA?style=for-the-badge&logo=biome&logoColor=white" alt="Biome" />
+  <img src="https://img.shields.io/badge/Vitest-6E9F18?style=for-the-badge&logo=vitest&logoColor=white" alt="Vitest" />
+  <img src="https://img.shields.io/badge/Fastify-000000?style=for-the-badge&logo=fastify&logoColor=white" alt="Fastify" />
+  <img src="https://img.shields.io/badge/Docker-2496ED?style=for-the-badge&logo=docker&logoColor=white" alt="Docker" />
+  <img src="https://img.shields.io/badge/GitHub_Actions-2088FF?style=for-the-badge&logo=github-actions&logoColor=white" alt="GitHub Actions" />
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/version-0.1.0-blue?style=flat-square" alt="Version" />
+  <img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License" />
+</p>
+
+> **Forge production-ready projects from configurable blueprints.**
+
+`genrex` is a modern, lightweight project scaffolding CLI engine. Rather than copying generic boilerplates, it generates strongly-typed, coherent software projects with Biome, Vitest, CI/CD, and Docker support tailored to your stack.
+
+---
+
+## Tech Stack & Ecosystem
+
+- **Language & Runtime:** TypeScript (Strict, Native ESM), Node.js (>=20)
+- **Code Quality & Testing:** Biome (Format/Lint), Vitest
+- **API Framework:** Fastify + `tsx` hot-reload
+- **DevOps & Containers:** Multi-stage Docker, GitHub Actions CI
+- **Package Managers:** `pnpm`, `npm`, `yarn`, `bun`
+
+---
+
+## Quick Start
+
+Run directly with `npx`:
+
+```bash
+npx genrex create my-api --blueprint node-api
+```
+
+Preview what will be generated without writing to disk:
+
+```bash
+npx genrex create my-cli --dry-run
+```
+
+---
+
+## Blueprints
+
+| Blueprint | ID | Description |
+|---|---|---|
+| **TypeScript CLI** | `ts-cli` | Standalone CLI binary, ESM, Biome formatting, Vitest |
+| **Node.js API** | `node-api` | Fastify REST API, hot-reload (`tsx`), healthchecks |
+| **TypeScript Library** | `ts-lib` | Publishable library with dual ESM exports and `.d.ts` declaration maps |
+
+View all blueprints anytime:
+
+```bash
+genrex list
+genrex info ts-cli
+```
+
+---
+
+## Commands & Usage
+
+### 1. Create a Project
+
+```bash
+genrex create <project-name> [options]
+```
+
+**Options:**
+
+| Flag | Description | Default |
+|---|---|---|
+| `--blueprint <id>` | Blueprint template (`ts-cli`, `node-api`, `ts-lib`) | `ts-cli` |
+| `--package-manager <pm>` | `npm`, `pnpm`, `yarn`, or `bun` | `pnpm` |
+| `--git` | Initialize empty Git repository | `false` |
+| `--github-actions` | Generate GitHub Actions CI test/lint workflow | `false` |
+| `--docker` | Generate optimized multi-stage Dockerfile | `false` |
+| `--dry-run` | Preview file tree and dependencies without writing files | `false` |
+| `--skip-install` | Scaffold files without running package installation | `false` |
+
+**Full-fledged Example:**
+
+```bash
+genrex create billing-service \
+  --blueprint node-api \
+  --package-manager pnpm \
+  --git \
+  --github-actions \
+  --docker
+```
+
+---
+
+### 2. Environment Doctor
+
+Diagnose your environment tools in one command:
+
+```bash
+genrex doctor
+```
+
+```text
+genrex Doctor
+
+Environment
+────────────────────────────────────────
+✓ Node.js        v22.20.0
+✓ npm            10.9.3
+✓ Git            git version 2.49.0
+○ pnpm           not found (optional)
+○ yarn           not found (optional)
+○ bun            not found (optional)
+
+Environment is ready.
+```
+
+---
+
+## Design Principles
+
+- **Zero Unnecessary Bloat:** Fast execution with near-zero runtime dependencies.
+- **Fail Safely:** Refuses to overwrite non-empty directories; pre-validates all input and tools before modifying the disk.
+- **Modern Standards:** Native ESM, strict TypeScript, Biome linter/formatter, and Vitest by default.
+- **Cross-Platform:** Works seamlessly on Windows, macOS, and Linux.
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/waeterr/genrex.git
+cd genrex
+npm install
+npm test
+npm run build
+```
+
+---
+
+## License
+
+MIT © [waeterr](https://github.com/waeterr)

package/dist/src/blueprints.js

@@ -0,0 +1,29 @@
+export const blueprints = [
+    {
+        id: "ts-cli",
+        name: "TypeScript CLI",
+        version: "1.0.0",
+        description: "Production-ready TypeScript CLI tool.",
+        language: "TypeScript",
+        capabilities: ["testing", "formatting", "git", "github-actions", "docker"],
+    },
+    {
+        id: "node-api",
+        name: "Node.js API",
+        version: "1.0.0",
+        description: "Node.js REST API with routing and healthchecks.",
+        language: "TypeScript",
+        capabilities: ["testing", "formatting", "git", "github-actions", "docker"],
+    },
+    {
+        id: "ts-lib",
+        name: "TypeScript Library",
+        version: "1.0.0",
+        description: "Publishable TypeScript library blueprint.",
+        language: "TypeScript",
+        capabilities: ["testing", "formatting", "git", "github-actions"],
+    },
+];
+export function getBlueprint(id) {
+    return blueprints.find((b) => b.id === id);
+}

package/dist/src/ci.js

@@ -0,0 +1,31 @@
+export function generateCiWorkflow(pm) {
+    const steps = [
+        "      - uses: actions/checkout@v4",
+    ];
+    if (pm === "pnpm") {
+        steps.push("      - uses: pnpm/action-setup@v4\n        with:\n          version: 9", "      - uses: actions/setup-node@v4\n        with:\n          node-version: 22\n          cache: 'pnpm'", "      - run: pnpm install", "      - run: pnpm run lint", "      - run: pnpm test");
+    }
+    else if (pm === "bun") {
+        steps.push("      - uses: oven-sh/setup-bun@v2", "      - run: bun install", "      - run: bun run lint", "      - run: bun test");
+    }
+    else if (pm === "yarn") {
+        steps.push("      - uses: actions/setup-node@v4\n        with:\n          node-version: 22\n          cache: 'yarn'", "      - run: yarn install", "      - run: yarn run lint", "      - run: yarn test");
+    }
+    else {
+        steps.push("      - uses: actions/setup-node@v4\n        with:\n          node-version: 22\n          cache: 'npm'", "      - run: npm install", "      - run: npm run lint", "      - run: npm test");
+    }
+    return `name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+${steps.join("\n")}
+`;
+}

package/dist/src/config.js

@@ -0,0 +1,23 @@
+export function validateProjectName(name) {
+    if (!name || name.trim() === "") {
+        return "Project name cannot be empty";
+    }
+    if (!/^[a-z0-9-_@/]+$/.test(name)) {
+        return "Project name must contain only lowercase letters, numbers, hyphens, underscores, or scopes";
+    }
+    if (name.startsWith("-") || name.startsWith("_")) {
+        return "Project name cannot start with - or _";
+    }
+    return null;
+}
+export function validateConfig(config) {
+    const errors = [];
+    const nameError = validateProjectName(config.name);
+    if (nameError) {
+        errors.push(nameError);
+    }
+    if (!config.blueprint) {
+        errors.push("Blueprint is required");
+    }
+    return errors;
+}

package/dist/src/create.js

@@ -0,0 +1,108 @@
+import { basename, resolve } from "node:path";
+import { getBlueprint } from "./blueprints.js";
+import { validateConfig, } from "./config.js";
+import { buildTsCliFiles, prepareDestination, writeProjectFiles, } from "./generator.js";
+import { buildNodeApiFiles } from "./generators/node-api.js";
+import { buildTsLibFiles } from "./generators/ts-lib.js";
+import { checkGit, initGit } from "./git.js";
+import { installDependencies } from "./pm.js";
+export function createProject(name, options) {
+    if (!name) {
+        fail("Project name is required. Example: genrex create my-project");
+        return;
+    }
+    const config = {
+        name: basename(name),
+        destination: resolve(name),
+        blueprint: options.blueprint ?? "ts-cli",
+        packageManager: options.packageManager ?? "pnpm",
+        testing: "vitest",
+        formatter: "biome",
+        git: options.git,
+        githubActions: options.githubActions,
+        docker: options.docker,
+    };
+    const errors = validateConfig(config);
+    const blueprint = getBlueprint(config.blueprint);
+    if (!blueprint) {
+        errors.push(`Blueprint '${config.blueprint}' not found`);
+    }
+    if (errors.length > 0 || !blueprint) {
+        fail(`Invalid configuration:\n${errors.map((error) => `  - ${error}`).join("\n")}`);
+        return;
+    }
+    let files;
+    if (config.blueprint === "ts-cli") {
+        files = buildTsCliFiles(config);
+    }
+    else if (config.blueprint === "node-api") {
+        files = buildNodeApiFiles(config);
+    }
+    else if (config.blueprint === "ts-lib") {
+        files = buildTsLibFiles(config);
+    }
+    else {
+        fail(`Generation for blueprint '${config.blueprint}' is not implemented yet. Supported: ts-cli, node-api, ts-lib.`);
+        return;
+    }
+    if (options.git) {
+        const gitStatus = checkGit();
+        if (!gitStatus.available) {
+            fail("Git was requested (--git), but 'git' is not installed or not in PATH.");
+            return;
+        }
+    }
+    if (options.dryRun) {
+        console.log("DRY RUN\n");
+        console.log(`Blueprint:       ${blueprint.name}`);
+        console.log(`Destination:     ${config.destination}`);
+        console.log(`Package manager: ${config.packageManager}`);
+        console.log(`Git:             ${options.git ? "yes" : "no"}`);
+        console.log(`GitHub Actions:  ${options.githubActions ? "yes" : "no"}`);
+        console.log(`Docker:          ${options.docker ? "yes" : "no"}`);
+        console.log("\nWould create:");
+        for (const f of files) {
+            console.log(`  - ${f.path}`);
+        }
+        console.log("\nWould install:");
+        console.log("  devDependencies: typescript, vitest, @biomejs/biome, @types/node");
+        if (options.git) {
+            console.log("\nWould execute:");
+            console.log("  git init");
+        }
+        return;
+    }
+    try {
+        prepareDestination(config.destination);
+        writeProjectFiles(config.destination, files);
+        console.log(`✓ Project scaffolded in ${config.destination}`);
+        if (options.skipInstall) {
+            console.log("○ Skipped dependency installation (--skip-install)");
+        }
+        else {
+            console.log(`Installing dependencies using ${config.packageManager}...`);
+            installDependencies(config.packageManager, config.destination);
+            console.log("✓ Dependencies installed");
+        }
+        if (options.git) {
+            console.log("Initializing Git repository...");
+            initGit(config.destination);
+            console.log("✓ Git repository initialized");
+        }
+        console.log("\nDone. Next steps:");
+        console.log(`  cd ${name}`);
+        if (options.skipInstall) {
+            console.log(`  ${config.packageManager} install`);
+        }
+        console.log(`  ${config.packageManager} run build`);
+        console.log(`  ${config.packageManager} test`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        fail(`Generation failed: ${message}`);
+    }
+}
+function fail(message) {
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}

package/dist/src/docker.js

@@ -0,0 +1,57 @@
+export function generateDockerfile(config) {
+    if (config.blueprint === "ts-cli") {
+        return `FROM node:22-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM node:22-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY package*.json ./
+CMD ["node", "dist/src/index.js"]
+`;
+    }
+    if (config.blueprint === "node-api") {
+        return `FROM node:22-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM node:22-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+COPY package*.json ./
+EXPOSE 3000
+CMD ["node", "dist/src/server.js"]
+`;
+    }
+    return `FROM node:22-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+CMD ["npm", "test"]
+`;
+}
+export function generateDockerignore() {
+    return `node_modules
+dist
+coverage
+*.log
+.git
+.github
+tests
+*.test.ts
+README.md
+tsconfig.json
+biome.json
+`;
+}

package/dist/src/doctor.js

@@ -0,0 +1,60 @@
+import { spawnSync } from "node:child_process";
+import { checkGit } from "./git.js";
+export function runDoctor() {
+    console.log("genrex Doctor\n");
+    console.log("Environment\n" + "─".repeat(40) + "\n");
+    const checks = [
+        checkTool("Node.js", "node", ["--version"], false),
+        checkTool("npm", "npm", ["--version"], false),
+        checkTool("pnpm", "pnpm", ["--version"], true),
+        checkTool("yarn", "yarn", ["--version"], true),
+        checkTool("bun", "bun", ["--version"], true),
+        checkGitTool(),
+    ];
+    for (const check of checks) {
+        const status = check.available ? "✓" : check.optional ? "○" : "✗";
+        const label = check.name.padEnd(14);
+        const version = check.version ? check.version : check.optional ? "not found (optional)" : "not found";
+        console.log(`${status} ${label} ${version}`);
+    }
+    const critical = checks.filter((c) => !c.available && !c.optional);
+    console.log();
+    if (critical.length === 0) {
+        console.log("Environment is ready.");
+    }
+    else {
+        console.log("⚠ Missing required tools:");
+        for (const c of critical) {
+            console.log(`  - ${c.name}`);
+        }
+        process.exitCode = 1;
+    }
+}
+function checkTool(name, command, args, optional) {
+    try {
+        const isWindows = process.platform === "win32";
+        // Node.js is always node.exe/node; npm/pnpm/yarn/bun are batch files (.cmd) on Windows
+        const binary = isWindows && command !== "node" ? `${command}.cmd` : command;
+        const result = spawnSync(binary, args, {
+            encoding: "utf8",
+            shell: isWindows,
+            timeout: 5000,
+        });
+        if (result.status === 0 && result.stdout) {
+            return { name, available: true, version: result.stdout.trim(), optional };
+        }
+        return { name, available: false, optional };
+    }
+    catch {
+        return { name, available: false, optional };
+    }
+}
+function checkGitTool() {
+    const git = checkGit();
+    return {
+        name: "Git",
+        available: git.available,
+        version: git.version,
+        optional: true,
+    };
+}

package/dist/src/generator.js

@@ -0,0 +1,140 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { generateCiWorkflow } from "./ci.js";
+import { generateDockerfile, generateDockerignore } from "./docker.js";
+export function prepareDestination(destination) {
+    if (existsSync(destination)) {
+        const files = readdirSync(destination);
+        if (files.length > 0) {
+            throw new Error(`Destination directory '${destination}' already exists and is not empty.`);
+        }
+        return;
+    }
+    mkdirSync(destination, { recursive: true });
+}
+export function buildTsCliFiles(config) {
+    const files = [
+        {
+            path: "package.json",
+            content: JSON.stringify({
+                name: config.name,
+                version: "0.1.0",
+                type: "module",
+                bin: {
+                    [config.name]: "./dist/index.js",
+                },
+                scripts: {
+                    build: "tsc",
+                    dev: "tsc --watch",
+                    start: "node dist/index.js",
+                    test: "vitest run",
+                    format: "biome format --write .",
+                    lint: "biome check .",
+                },
+                devDependencies: {
+                    "@biomejs/biome": "^1.9.0",
+                    "@types/node": "^22.0.0",
+                    typescript: "^5.8.0",
+                    vitest: "^2.1.0",
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "tsconfig.json",
+            content: JSON.stringify({
+                compilerOptions: {
+                    target: "ES2022",
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    outDir: "dist",
+                    rootDir: "src",
+                    strict: true,
+                    skipLibCheck: true,
+                },
+                include: ["src/**/*"],
+            }, null, 2) + "\n",
+        },
+        {
+            path: "biome.json",
+            content: JSON.stringify({
+                $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+                formatter: {
+                    enabled: true,
+                    indentStyle: "space",
+                    indentWidth: 2,
+                },
+                linter: {
+                    enabled: true,
+                    rules: {
+                        recommended: true,
+                    },
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "README.md",
+            content: `# ${config.name}
+
+Generated with [genrex](https://github.com/waeterr/genrex).
+
+## Scripts
+
+- \`${config.packageManager} run build\` — Build with TypeScript
+- \`${config.packageManager} run start\` — Run compiled output
+- \`${config.packageManager} test\` — Run tests with Vitest
+- \`${config.packageManager} run lint\` — Lint with Biome
+`,
+        },
+        {
+            path: ".gitignore",
+            content: `node_modules/
+dist/
+coverage/
+*.log
+`,
+        },
+        {
+            path: "src/index.ts",
+            content: `#!/usr/bin/env node
+
+export function main(): void {
+  console.log("Hello from ${config.name}!");
+}
+
+main();
+`,
+        },
+        {
+            path: "tests/index.test.ts",
+            content: `import { expect, test } from "vitest";
+
+test("smoke test", () => {
+  expect(1 + 1).toBe(2);
+});
+`,
+        },
+    ];
+    if (config.githubActions) {
+        files.push({
+            path: ".github/workflows/ci.yml",
+            content: generateCiWorkflow(config.packageManager),
+        });
+    }
+    if (config.docker) {
+        files.push({
+            path: "Dockerfile",
+            content: generateDockerfile(config),
+        }, {
+            path: ".dockerignore",
+            content: generateDockerignore(),
+        });
+    }
+    return files;
+}
+export function writeProjectFiles(destination, files) {
+    for (const file of files) {
+        const fullPath = join(destination, file.path);
+        mkdirSync(dirname(fullPath), { recursive: true });
+        writeFileSync(fullPath, file.content, "utf8");
+    }
+}

package/dist/src/generators/node-api.js

@@ -0,0 +1,144 @@
+import { generateCiWorkflow } from "../ci.js";
+import { generateDockerfile, generateDockerignore } from "../docker.js";
+export function buildNodeApiFiles(config) {
+    const files = [
+        {
+            path: "package.json",
+            content: JSON.stringify({
+                name: config.name,
+                version: "0.1.0",
+                type: "module",
+                scripts: {
+                    build: "tsc",
+                    dev: "tsx watch src/server.ts",
+                    start: "node dist/server.js",
+                    test: "vitest run",
+                    format: "biome format --write .",
+                    lint: "biome check .",
+                },
+                dependencies: {
+                    fastify: "^5.1.0",
+                },
+                devDependencies: {
+                    "@biomejs/biome": "^1.9.0",
+                    "@types/node": "^22.0.0",
+                    tsx: "^4.19.0",
+                    typescript: "^5.8.0",
+                    vitest: "^2.1.0",
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "tsconfig.json",
+            content: JSON.stringify({
+                compilerOptions: {
+                    target: "ES2022",
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    outDir: "dist",
+                    rootDir: "src",
+                    strict: true,
+                    skipLibCheck: true,
+                },
+                include: ["src/**/*"],
+            }, null, 2) + "\n",
+        },
+        {
+            path: "biome.json",
+            content: JSON.stringify({
+                $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+                formatter: {
+                    enabled: true,
+                    indentStyle: "space",
+                    indentWidth: 2,
+                },
+                linter: {
+                    enabled: true,
+                    rules: {
+                        recommended: true,
+                    },
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "README.md",
+            content: `# ${config.name}
+
+Node.js REST API built with Fastify.
+
+Generated with [genrex](https://github.com/waeterr/genrex).
+
+## Scripts
+
+- \`${config.packageManager} run dev\` — Start development server with watch
+- \`${config.packageManager} run build\` — Build with TypeScript
+- \`${config.packageManager} start\` — Run production server
+- \`${config.packageManager} test\` — Run tests with Vitest
+- \`${config.packageManager} run lint\` — Lint with Biome
+`,
+        },
+        {
+            path: ".gitignore",
+            content: `node_modules/
+dist/
+coverage/
+*.log
+`,
+        },
+        {
+            path: "src/server.ts",
+            content: `import Fastify from "fastify";
+
+const server = Fastify({
+  logger: true,
+});
+
+server.get("/health", async () => {
+  return { status: "ok", timestamp: new Date().toISOString() };
+});
+
+server.get("/", async () => {
+  return { message: "Welcome to ${config.name}" };
+});
+
+const start = async () => {
+  try {
+    await server.listen({ port: 3000, host: "0.0.0.0" });
+  } catch (err) {
+    server.log.error(err);
+    process.exit(1);
+  }
+};
+
+start();
+`,
+        },
+        {
+            path: "tests/server.test.ts",
+            content: `import { expect, test } from "vitest";
+
+test("example test", () => {
+  expect(1 + 1).toBe(2);
+});
+
+// ponytail: add integration tests with Fastify .inject()
+`,
+        },
+    ];
+    if (config.githubActions) {
+        files.push({
+            path: ".github/workflows/ci.yml",
+            content: generateCiWorkflow(config.packageManager),
+        });
+    }
+    if (config.docker) {
+        files.push({
+            path: "Dockerfile",
+            content: generateDockerfile(config),
+        }, {
+            path: ".dockerignore",
+            content: generateDockerignore(),
+        });
+    }
+    return files;
+}

package/dist/src/generators/ts-lib.js

@@ -0,0 +1,142 @@
+import { generateCiWorkflow } from "../ci.js";
+export function buildTsLibFiles(config) {
+    const files = [
+        {
+            path: "package.json",
+            content: JSON.stringify({
+                name: config.name,
+                version: "0.1.0",
+                type: "module",
+                main: "./dist/index.js",
+                types: "./dist/index.d.ts",
+                exports: {
+                    ".": {
+                        import: "./dist/index.js",
+                        types: "./dist/index.d.ts",
+                    },
+                },
+                files: ["dist"],
+                scripts: {
+                    build: "tsc",
+                    test: "vitest run",
+                    format: "biome format --write .",
+                    lint: "biome check .",
+                    prepublishOnly: "npm run build && npm test",
+                },
+                devDependencies: {
+                    "@biomejs/biome": "^1.9.0",
+                    "@types/node": "^22.0.0",
+                    typescript: "^5.8.0",
+                    vitest: "^2.1.0",
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "tsconfig.json",
+            content: JSON.stringify({
+                compilerOptions: {
+                    target: "ES2022",
+                    module: "NodeNext",
+                    moduleResolution: "NodeNext",
+                    outDir: "dist",
+                    rootDir: "src",
+                    declaration: true,
+                    declarationMap: true,
+                    sourceMap: true,
+                    strict: true,
+                    skipLibCheck: true,
+                },
+                include: ["src/**/*"],
+            }, null, 2) + "\n",
+        },
+        {
+            path: "biome.json",
+            content: JSON.stringify({
+                $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+                formatter: {
+                    enabled: true,
+                    indentStyle: "space",
+                    indentWidth: 2,
+                },
+                linter: {
+                    enabled: true,
+                    rules: {
+                        recommended: true,
+                    },
+                },
+            }, null, 2) + "\n",
+        },
+        {
+            path: "README.md",
+            content: `# ${config.name}
+
+TypeScript library.
+
+Generated with [genrex](https://github.com/waeterr/genrex).
+
+## Installation
+
+\`\`\`bash
+${config.packageManager} add ${config.name}
+\`\`\`
+
+## Usage
+
+\`\`\`typescript
+import { greet } from "${config.name}";
+
+console.log(greet("world"));
+\`\`\`
+
+## Scripts
+
+- \`${config.packageManager} run build\` — Build TypeScript to dist/
+- \`${config.packageManager} test\` — Run tests with Vitest
+- \`${config.packageManager} run lint\` — Lint with Biome
+`,
+        },
+        {
+            path: ".gitignore",
+            content: `node_modules/
+dist/
+coverage/
+*.log
+`,
+        },
+        {
+            path: ".npmignore",
+            content: `src/
+tests/
+coverage/
+*.test.ts
+*.config.*
+biome.json
+tsconfig.json
+`,
+        },
+        {
+            path: "src/index.ts",
+            content: `export function greet(name: string): string {
+  return \`Hello, \${name}!\`;
+}
+`,
+        },
+        {
+            path: "tests/index.test.ts",
+            content: `import { expect, test } from "vitest";
+import { greet } from "../src/index.js";
+
+test("greet returns greeting", () => {
+  expect(greet("world")).toBe("Hello, world!");
+});
+`,
+        },
+    ];
+    if (config.githubActions) {
+        files.push({
+            path: ".github/workflows/ci.yml",
+            content: generateCiWorkflow(config.packageManager),
+        });
+    }
+    return files;
+}

package/dist/src/git.js

@@ -0,0 +1,23 @@
+import { execFileSync, spawnSync } from "node:child_process";
+export function checkGit() {
+    try {
+        const result = spawnSync("git", ["--version"], {
+            encoding: "utf8",
+            shell: false,
+        });
+        if (result.status === 0 && result.stdout) {
+            return { available: true, version: result.stdout.trim() };
+        }
+        return { available: false };
+    }
+    catch {
+        return { available: false };
+    }
+}
+export function initGit(cwd) {
+    execFileSync("git", ["init"], {
+        cwd,
+        stdio: "inherit",
+        shell: false,
+    });
+}

package/dist/src/index.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { createProject } from "./create.js";
+import { runDoctor } from "./doctor.js";
+import { blueprints, getBlueprint } from "./blueprints.js";
+const [command, ...args] = process.argv.slice(2);
+switch (command) {
+    case "create":
+        runCreate(args);
+        break;
+    case "list":
+        listBlueprints();
+        break;
+    case "info":
+        showBlueprintInfo(args[0]);
+        break;
+    case "doctor":
+        runDoctor();
+        break;
+    case "--help":
+    case "-h":
+    case undefined:
+        printHelp();
+        break;
+    case "--version":
+    case "-v":
+        console.log("0.1.0");
+        break;
+    default:
+        console.error(`Unknown command: ${command}`);
+        console.error("Run 'genrex --help' for usage.");
+        process.exitCode = 1;
+}
+function runCreate(args) {
+    const [name, ...flags] = args;
+    const options = {
+        dryRun: false,
+        skipInstall: false,
+        git: false,
+        githubActions: false,
+        docker: false,
+    };
+    for (let index = 0; index < flags.length; index += 1) {
+        const flag = flags[index];
+        if (flag === "--dry-run") {
+            options.dryRun = true;
+        }
+        else if (flag === "--skip-install") {
+            options.skipInstall = true;
+        }
+        else if (flag === "--git") {
+            options.git = true;
+        }
+        else if (flag === "--github-actions") {
+            options.githubActions = true;
+        }
+        else if (flag === "--docker") {
+            options.docker = true;
+        }
+        else if (flag === "--blueprint") {
+            options.blueprint = flags[++index];
+        }
+        else if (flag === "--package-manager") {
+            const packageManager = flags[++index];
+            if (!["npm", "pnpm", "yarn", "bun"].includes(packageManager)) {
+                console.error(`Error: Unsupported package manager '${packageManager}'.`);
+                process.exitCode = 1;
+                return;
+            }
+            options.packageManager = packageManager;
+        }
+        else {
+            console.error(`Error: Unknown create option '${flag}'.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    createProject(name, options);
+}
+function listBlueprints() {
+    console.log("Available blueprints:\n");
+    for (const b of blueprints) {
+        console.log(`  ${b.id.padEnd(12)} ${b.name} (${b.language})`);
+        console.log(`               ${b.description}\n`);
+    }
+}
+function showBlueprintInfo(id) {
+    if (!id) {
+        console.error("Error: Blueprint ID required. Example: genrex info ts-cli");
+        process.exitCode = 1;
+        return;
+    }
+    const bp = getBlueprint(id);
+    if (!bp) {
+        console.error(`Error: Blueprint '${id}' not found.`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`${bp.name} (${bp.id})`);
+    console.log(`Version:      ${bp.version}`);
+    console.log(`Language:     ${bp.language}`);
+    console.log(`Description:  ${bp.description}`);
+    console.log("Capabilities:");
+    for (const c of bp.capabilities) {
+        console.log(`  - ${c}`);
+    }
+}
+function printHelp() {
+    console.log(`genrex — Project Blueprint Engine
+
+Usage:
+  genrex <command> [options]
+
+Commands:
+  list                              List available blueprints
+  info <name>                       Show blueprint details
+  create <name> --dry-run           Preview project generation
+  doctor                            Check local environment
+
+Create options:
+  --blueprint <id>                  Blueprint ID (default: ts-cli)
+  --package-manager <manager>       npm, pnpm, yarn, or bun (default: pnpm)
+  --dry-run                         Preview without filesystem changes
+  --skip-install                    Do not install dependencies
+  --git                             Initialize a Git repository
+  --github-actions                  Generate GitHub Actions CI workflow
+  --docker                          Generate Dockerfile & .dockerignore
+
+Options:
+  -h, --help                        Show help
+  -v, --version                     Show version`);
+}

package/dist/src/pm.js

@@ -0,0 +1,10 @@
+import { execFileSync } from "node:child_process";
+export function installDependencies(pm, cwd) {
+    const isWindows = process.platform === "win32";
+    const cmd = isWindows ? `${pm}.cmd` : pm;
+    execFileSync(cmd, ["install"], {
+        cwd,
+        stdio: "inherit",
+        shell: false,
+    });
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "genrex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Forge production-ready TypeScript projects from blueprints",
+  "license": "MIT",
+  "type": "module",
+  "author": "waeterr",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/waeterr/genrex.git"
+  },
+  "keywords": [
+    "cli",
+    "scaffolding",
+    "blueprint",
+    "generator",
+    "typescript",
+    "fastify",
+    "vitest",
+    "biome"
+  ],
+  "bin": {
+    "genrex": "./dist/src/index.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/src/index.js",
+    "test": "npm run build && node --test dist/tests/**/*.test.js",
+    "prepublishOnly": "npm run check && npm test"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}