create-lumen 2.0.0-alpha.2 → 2.0.0-beta.2

package/README.md

@@ -1,6 +1,6 @@
 # create-lumen
 
-A scaffolder that generates production-ready React + Vite projects (feature-based, type-based, hybrid, or none).
+A scaffolder that generates production-ready **React + Vite** or **Next.js** projects (App Router / Pages Router), with a choice of architecture: feature-based, type-based, hybrid, or none.
 
 Note: this repository is the CLI scaffolder itself, not a generated app. Generated projects live in the target folder you create.
 
@@ -14,6 +14,8 @@ cd my-app
 npm run dev
 ```
 
+> The v2 line (React + Vite + Next.js, manifest v2) is available on the `beta` dist-tag while v2 is in prerelease: `npm create lumen@beta my-app`.
+
 ### Non-interactive flags
 
 Quick Setup (TypeScript + Tailwind + Feature-based + Router + ESLint + Prettier + Vitest), no prompts:
@@ -26,20 +28,28 @@ npm create lumen -- -y my-app
 npm create lumen my-app -- --yes
 ```
 
-Scaffold using a template preset (`react-ts`, `react-js`, `react-type-ts`, `react-type-js`):
+Scaffold using a template preset (`react-ts`, `react-js`, `react-type-ts`, `react-type-js`, `next-ts`, `next-js`, `next-pages-ts`, `next-pages-js`):
 
 ```bash
 npm create lumen my-app -- --template react-ts
 # or
-npm create lumen my-app -- -t react-type-js
+npm create lumen my-app -- -t next-ts
 ```
 
 Choose framework and architecture directly:
 
 ```bash
 npm create lumen my-app -- --framework react --arch none
+
+# Next.js — the router is asked interactively (App Router recommended):
+npm create lumen my-app -- -f next
+# ...or pin the variant outright:
+npm create lumen my-app -- -f next:app-router
+npm create lumen my-app -- -f next:pages-router
 ```
 
+Interactively, the framework is the first prompt (React + Vite / Next.js), followed by a router step when Next.js is selected; every later option gates on that choice.
+
 Drive scaffolding directly from a manifest file or inline JSON (manifest v2):
 
 ```bash
@@ -70,20 +80,25 @@ create-lumen my-app      # after npm link
 
 ## Features
 
+- **Two frameworks:** React + Vite (SPA) or Next.js (App Router / Pages Router) — selected interactively or via `-f`
 - Architecture choice: feature-based, type-based, hybrid, or none (per-framework availability)
 - TypeScript or JavaScript output
 - CSS frameworks: Tailwind CSS v4 (CSS-first `@theme`, v3 dropped) or none
+- **UI kit: shadcn/ui** (gated to Tailwind; primitives + `cn` helper land in the mapped `paths.ui`)
 - Optional state management: Zustand or Redux Toolkit
-- Optional router (React Router)
-- Optional testing: Vitest or Jest
+- Optional router (React Router — Vite only; Next.js uses filesystem routing)
+- Optional testing: Vitest or Jest (Next.js defaults to none until a Next-native overlay is verified)
+- **Next.js-native overlays:** server/client boundary demos + `no-server-imports-in-client` ESLint rule, `next/font` (Geist), `next/image`, filesystem routing examples, route handlers (`route.ts`) / API routes (`pages/api`)
+- **Next.js options:** `bundler: turbopack|webpack`, `adapter: node|vercel|cloudflare|static` (`next.config` overlays), `reactCompiler`, `linter: biome` — all validated against the capability model
 - Linting: ESLint (default), Oxlint, or Biome
 - Code formatter: Prettier or Oxfmt (chosen after the linter; `eslint-config-prettier` is auto-wired for the ESLint + Prettier combo)
-- Manifest v2: Emits a deterministic `lumen.config.json` (optional but recommended) validated against JSON Schema Draft 2020-12, including architecture validation modes and harness command configuration.
+- Manifest v2: Emits a deterministic `lumen.config.json` validated against JSON Schema Draft 2020-12, including architecture validation modes and harness command configuration.
 - Explicit path mapping: Target directories declared for `lumen-cli` code generation
 - Optional Axios setup and icon libraries
 - Auto `git init`, generated `README` (with a project description reflecting the chosen tooling) and `LICENSE`
 - `.env.example` scaffolded, and the generated `.gitignore` excludes env files (`.env`, `.env.*`) while keeping `.env.example`
 - `@/` path alias configured (`tsconfig`/`jsconfig` + Vite)
+- **Agent docs:** optional `.lumen/` context directory (project, architecture, conventions) via prompt or `--agent-docs`
 
 Your selected options are cached and offered as defaults on subsequent runs.
 
@@ -206,6 +221,9 @@ The manifest now includes:
 ### Ecosystem Documentation & Contracts
 
 - **[Documentation Index](./docs/README.md):** Complete overview of specifications, ADRs, and developer guides.
+- **[Next.js App Router Guide](./docs/next-app-router.md):** App Router scaffold, filesystem routing, route handlers, server/client boundaries, `next/font` and `next/image`.
+- **[Next.js Pages Router Guide](./docs/next-pages-router.md):** Pages Router scaffold, API routes, `_app`/`_document` wiring.
+- **[Deployment Adapters Guide](./docs/next-adapters.md):** Adapter matrix (Node, Vercel, Cloudflare, static), bundler choice and Biome setup for Next.js.
 - **[Generator Engine & Capabilities Guide (M2)](./docs/engine-capabilities.md):** Capability model, template composition, shadcn/ui on Tailwind v4, architecture presets, and Bootstrap removal.
 - **[Manifest v2 Overview](./docs/manifest-v2.md):** Specification of the nested schema, validation behavior, and the new harness and architecture validation fields.
 - **[Shared Contract: `create-lumen` ↔ `lumen-cli`](./docs/contracts/manifest-v2-contract.md):** The agreed contract for path mapping, barrel conventions, version negotiation, and the harness/configuration interface.

package/bin/cli.js

@@ -25,7 +25,7 @@ console.log(
   chalk.bold.cyan("\n  ✦ LUMEN") +
     chalk.gray(` v${version}`) +
     chalk.gray(
-      "\n  Scaffold a React + Vite project with architecture choice\n"
+      "\n  Scaffold a React, Vite, or Next.js project with architecture choice\n"
     )
 );
 
@@ -36,6 +36,7 @@ main({
   projectName: cliArgs.projectName,
   manifest: cliArgs.manifest,
   template: cliArgs.template,
+  framework: cliArgs.framework,
   arch: cliArgs.arch,
 }).catch((e) => {
   console.error(chalk.red("\nError:"), e.message || e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-lumen",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-beta.2",
   "description": "Scaffold a React + Vite project with architecture choice: feature-based, type-based, hybrid, or none.",
   "type": "module",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/LUMEN-SH/create-lumen"
+    "url": "https://github.com/strophix-software/create-lumen"
   },
   "files": [
     "bin/",

package/schema/lumen.config.v2.json

@@ -247,6 +247,35 @@
       ],
       "additionalProperties": false
     },
+    "database": {
+      "type": "object",
+      "properties": {
+        "orm": {
+          "type": "string",
+          "enum": [
+            "prisma",
+            "none"
+          ]
+        },
+        "provider": {
+          "default": "postgresql",
+          "type": "string",
+          "enum": [
+            "postgresql"
+          ]
+        }
+      },
+      "required": [
+        "orm"
+      ],
+      "additionalProperties": false
+    },
+    "docker": {
+      "type": "boolean"
+    },
+    "routeGroups": {
+      "type": "boolean"
+    },
     "reactCompiler": {
       "type": "boolean"
     },

package/src/agent-context.js

@@ -19,17 +19,19 @@ function resolveManifest(manifestOrResponses) {
 }
 
 /**
- * Render the short agent conventions markdown from a manifest.
- * Deterministic: derived only from stable manifest fields.
+ * Render the root AGENTS.md document from a manifest.
+ * Single Source of Truth (SSOT): references `lumen.config.json` directly.
+ * Byte-deterministic: derived only from stable manifest fields (no timestamps).
  * @param {object} manifest - validated manifest v2
  * @returns {string}
  */
-export function renderConventions(manifest) {
+export function renderAgentsMd(manifest) {
   const preset = manifest.architecture?.preset ?? manifest.architecture?.type ?? "feature-based";
   const validation = manifest.architecture?.validation ?? "strict";
   const paths = manifest.paths ?? {};
   const harness = manifest.harness ?? { commands: [] };
   const barrelFile = manifest.tooling?.language === "js" ? "index.js" : "index.ts";
+  const isNext = manifest.framework?.name === "next";
 
   const pathLines = Object.entries(paths)
     .map(([key, value]) => `- ${key}: \`${value}\``)
@@ -41,74 +43,96 @@ export function renderConventions(manifest) {
 
   const harnessSummary = (harness.commands ?? []).map((c) => `\`${c.command}\``).join(", ");
 
+  let nextSection = "";
+  if (isNext) {
+    nextSection =
+      `<!-- BEGIN:nextjs-agent-rules -->\n` +
+      `## This is NOT the Next.js you know\n` +
+      `This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in node_modules/next/dist/docs/ (resolved from this file's directory...) before writing any code. Heed deprecation notices.\n` +
+      `<!-- END:nextjs-agent-rules -->\n` +
+      `\n` +
+      `### Next.js Component Rules\n` +
+      `\n` +
+      `- By default, all components in the App Router are React Server Components (RSC).\n` +
+      `- Use the \`"use client"\` directive only at the top of files that require browser APIs, React state, or event handlers.\n` +
+      `- Never import server-only modules or secrets into client components.\n` +
+      `\n`;
+  }
+
+  const uiPath = paths.ui ?? "@/components/ui";
+  const componentsPath = paths.components ?? "@/components";
+
   return (
-    `# Lumen Agent Conventions\n` +
+    `# AGENTS.md\n` +
+    `\n` +
+    `> **Single Source of Truth (SSOT)**: Project configuration, paths, and harness definitions are defined in \`lumen.config.json\`. Consult \`lumen.config.json\` for the authoritative settings.\n` +
     `\n` +
-    `Generated from \`lumen.config.json\`. Resolve every file location via \`paths.*\` in \`.lumen/architecture.json\` (preset: \`${preset}\`, validation: \`${validation}\`).\n` +
+    `${nextSection}` +
+    `## Architecture & Conventions\n` +
     `\n` +
-    `## Rules\n` +
+    `- **Architecture Preset**: \`${preset}\`\n` +
+    `- **Validation Mode**: \`${validation}\` (${VALIDATION_NOTES[validation] ?? VALIDATION_NOTES.strict})\n` +
+    `- **Paths Resolution**: Resolve file locations via \`paths.*\` defined in \`lumen.config.json\` — never hardcode arbitrary alternative locations.\n` +
+    `- **Feature Barrels**: Every feature directory (under \`${paths.features ?? "src/features"}/<feature>/\`) must re-export its public API via \`${barrelFile}\`.\n` +
+    `- **Shared Imports**: Import shared utilities via \`@/shared\` (plus path aliases configured in tsconfig/jsconfig).\n` +
     `\n` +
-    `- Resolve all paths via \`paths.*\` — never hardcode alternative \`src/...\` locations.\n` +
-    `- Feature barrel: every \`src/features/<feature>/\` must re-export its public API via \`${barrelFile}\`.\n` +
-    `- Shared code: import shared utilities via \`@/shared\` (plus the \`@/...\` aliases from tsconfig/jsconfig).\n` +
-    `- Harness: before finishing, run each command in \`.lumen/project.json\` \`harness.commands\` in order (${harnessSummary}).\n` +
-    `- Validation mode \`${validation}\`: ${VALIDATION_NOTES[validation] ?? VALIDATION_NOTES.strict}\n` +
+    `## Component Taxonomy\n` +
     `\n` +
-    `## Paths\n` +
+    `Components must be organized strictly according to \`lumen.config.json\` path mappings:\n` +
+    `- **Atomic UI Primitives**: Base atoms and UI primitives (e.g. shadcn components) belong in \`paths.ui\` (\`${uiPath}\`).\n` +
+    `- **Compound Components**: Shared composite components belong in \`paths.components\` (\`${componentsPath}\`).\n` +
+    `- **Feature Components**: Domain-specific components belong inside their respective feature folder (e.g. \`${paths.features ?? "src/features"}/<feature>/components\`).\n` +
+    `\n` +
+    `Lumen CLI and AI agents must place primitive UI atoms under \`paths.ui\`, global compound components under \`paths.components\`, and feature-scoped components in their respective feature folders.\n` +
+    `\n` +
+    `## Path Mappings\n` +
     `\n` +
     `${pathLines}\n` +
     `\n` +
-    `## Harness\n` +
+    `## Validation Harness\n` +
+    `\n` +
+    `Before finishing work, run each harness command defined in \`lumen.config.json\` \`harness.commands\` in order (${harnessSummary}):\n` +
     `\n` +
     `${harnessLines}\n`
   );
 }
 
 /**
- * Build the deterministic agent-context payload from a validated manifest v2.
- * No timestamps — output must be byte-stable.
+ * Backward compatibility alias for renderAgentsMd.
+ * @param {object} manifest - validated manifest v2
+ * @returns {string}
+ */
+export function renderConventions(manifest) {
+  return renderAgentsMd(manifest);
+}
+
+/**
+ * Build deterministic agent context metadata.
+ * Retained for backwards compatibility with tests and callers.
  * @param {object} manifest - validated manifest v2
- * @returns {{ project: object, architecture: object, conventionsMd: string }}
+ * @returns {{ agentsMd: string, conventionsMd: string }}
  */
 export function buildAgentContext(manifest) {
-  const project = {
-    manifestVersion: manifest.manifestVersion,
-    framework: manifest.framework,
-    styling: manifest.styling,
-    tooling: manifest.tooling,
-    harness: manifest.harness,
-    docs: manifest.docs,
-  };
-  const architecture = {
-    preset: manifest.architecture?.preset ?? manifest.architecture?.type,
-    validation: manifest.architecture?.validation ?? "strict",
-    paths: manifest.paths,
+  const agentsMd = renderAgentsMd(manifest);
+  return {
+    agentsMd,
+    conventionsMd: agentsMd,
   };
-  const conventionsMd = renderConventions(manifest);
-  return { project, architecture, conventionsMd };
-}
-
-function writeJson(filePath, value) {
-  return fsp.writeFile(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 
 /**
- * Emit the .lumen agent context dir into a scaffolded project.
- * Accepts either a validated manifest v2 or scaffolder responses
- * (uses responses._manifestSource when present, else buildManifest).
- * Writes .lumen/project.json, .lumen/architecture.json, .lumen/conventions.md
- * with 2-space indent + trailing newline. Byte-deterministic (no timestamps).
+ * Emit AGENTS.md directly into project root.
+ * Accepts either a validated manifest v2 or scaffolder responses.
+ * Writes ${projectPath}/AGENTS.md with trailing newline. Byte-deterministic.
+ * Does not emit duplicate JSON files or .lumen/ directory.
  * @param {string} projectPath - absolute path to scaffolded project
  * @param {object} manifestOrResponses
- * @returns {Promise<string>} absolute path to the .lumen dir
+ * @returns {Promise<string>} absolute path to AGENTS.md
  */
 export async function emitAgentContext(projectPath, manifestOrResponses) {
   const manifest = resolveManifest(manifestOrResponses);
-  const { project, architecture, conventionsMd } = buildAgentContext(manifest);
-  const dir = path.join(projectPath, ".lumen");
-  await fsp.mkdir(dir, { recursive: true });
-  await writeJson(path.join(dir, "project.json"), project);
-  await writeJson(path.join(dir, "architecture.json"), architecture);
-  await fsp.writeFile(path.join(dir, "conventions.md"), conventionsMd, "utf8");
-  return dir;
+  const content = renderAgentsMd(manifest);
+  const filePath = path.join(projectPath, "AGENTS.md");
+  await fsp.writeFile(filePath, content, "utf8");
+  return filePath;
 }

package/src/cleanup.js

@@ -1,7 +1,25 @@
 import { deleteIfExists } from "@/utils/fs.js";
+import { promises as fsp } from "fs";
+import path from "path";
 
-export async function cleanupBoilerplate(projectPath) {
+export async function cleanupBoilerplate(projectPath, responses = {}) {
   await deleteIfExists(`${projectPath}/public`);
   await deleteIfExists(`${projectPath}/src/assets`);
   await deleteIfExists(`${projectPath}/.oxlintrc.json`);
+  await deleteIfExists(`${projectPath}/.provenance.json`);
+
+  const isNext =
+    responses?.framework?.name === "next" ||
+    responses?.frameworkName === "next" ||
+    (await fsp.stat(path.join(projectPath, "next.config.ts")).catch(() => false)) ||
+    (await fsp.stat(path.join(projectPath, "next.config.mjs")).catch(() => false)) ||
+    (await fsp.stat(path.join(projectPath, "next.config.js")).catch(() => false));
+
+  if (isNext) {
+    await deleteIfExists(`${projectPath}/src/app/App.tsx`);
+    await deleteIfExists(`${projectPath}/src/app/App.jsx`);
+    await deleteIfExists(`${projectPath}/src/app/hooks`);
+    await deleteIfExists(`${projectPath}/src/app/contexts`);
+    await deleteIfExists(`${projectPath}/src/app/providers`);
+  }
 }

package/src/cli-args.js

@@ -6,7 +6,6 @@ import { parseManifest } from "./manifest/schema.js";
 import {
   normalizeFramework,
   isPromptVisible,
-  getDefaultResponses,
 } from "./engine/capabilities.js";
 
 export const PRESETS = {
@@ -180,6 +179,78 @@ export const PRESETS = {
     gitInit: true,
     readme: true,
   },
+  "next-ts": {
+    frameworkName: "next",
+    frameworkVariant: "app-router",
+    architecture: "feature-based",
+    language: "ts",
+    cssFramework: "tailwind",
+    testing: "vitest",
+    router: false,
+    bundler: "turbopack",
+    stateManagement: "none",
+    iconLibrary: "none",
+    apiClient: "none",
+    linter: "eslint",
+    formatter: "prettier",
+    docsLanguage: "en",
+    gitInit: true,
+    readme: true,
+  },
+  "next-js": {
+    frameworkName: "next",
+    frameworkVariant: "app-router",
+    architecture: "feature-based",
+    language: "js",
+    cssFramework: "tailwind",
+    testing: "vitest",
+    router: false,
+    bundler: "turbopack",
+    stateManagement: "none",
+    iconLibrary: "none",
+    apiClient: "none",
+    linter: "eslint",
+    formatter: "prettier",
+    docsLanguage: "en",
+    gitInit: true,
+    readme: true,
+  },
+  "next-pages-ts": {
+    frameworkName: "next",
+    frameworkVariant: "pages-router",
+    architecture: "feature-based",
+    language: "ts",
+    cssFramework: "tailwind",
+    testing: "vitest",
+    router: false,
+    bundler: "turbopack",
+    stateManagement: "none",
+    iconLibrary: "none",
+    apiClient: "none",
+    linter: "eslint",
+    formatter: "prettier",
+    docsLanguage: "en",
+    gitInit: true,
+    readme: true,
+  },
+  "next-pages-js": {
+    frameworkName: "next",
+    frameworkVariant: "pages-router",
+    architecture: "feature-based",
+    language: "js",
+    cssFramework: "tailwind",
+    testing: "vitest",
+    router: false,
+    bundler: "turbopack",
+    stateManagement: "none",
+    iconLibrary: "none",
+    apiClient: "none",
+    linter: "eslint",
+    formatter: "prettier",
+    docsLanguage: "en",
+    gitInit: true,
+    readme: true,
+  },
 };
 
 /**
@@ -207,6 +278,18 @@ export function parseCliArgs(argv = process.argv.slice(2)) {
       framework: { type: "string", short: "f" },
       arch: { type: "string", short: "a" },
       architecture: { type: "string" },
+      bundler: { type: "string", short: "b" },
+      adapter: { type: "string" },
+      database: { type: "string" },
+      db: { type: "string" },
+      "react-compiler": { type: "boolean" },
+      reactCompiler: { type: "boolean" },
+      "route-groups": { type: "boolean" },
+      routeGroups: { type: "boolean" },
+      "agent-docs": { type: "boolean" },
+      agentDocs: { type: "boolean" },
+      docker: { type: "boolean" },
+      linter: { type: "string" },
       help: { type: "boolean", short: "h", default: false },
       version: { type: "boolean", short: "v", default: false },
     },
@@ -223,6 +306,18 @@ export function parseCliArgs(argv = process.argv.slice(2)) {
     else if (arch === "component" || arch === "component-based" || arch === "type") arch = "type-based";
   }
 
+  const bundler = values.bundler ? values.bundler.trim().toLowerCase() : null;
+  const adapter = values.adapter ? values.adapter.trim().toLowerCase() : null;
+  let database = values.database || values.db || null;
+  if (database) {
+    database = database.trim().toLowerCase();
+  }
+  const reactCompiler = values["react-compiler"] ?? values.reactCompiler ?? null;
+  const routeGroups = values["route-groups"] ?? values.routeGroups ?? null;
+  const agentDocs = values["agent-docs"] ?? values.agentDocs ?? null;
+  const docker = Boolean(values.docker);
+  const linter = values.linter ? values.linter.trim().toLowerCase() : null;
+
   return {
     projectName,
     quickSetup: Boolean(values.yes),
@@ -230,6 +325,14 @@ export function parseCliArgs(argv = process.argv.slice(2)) {
     template: values.template || null,
     framework: values.framework ? values.framework.trim() : null,
     arch,
+    bundler,
+    adapter,
+    database,
+    reactCompiler,
+    routeGroups,
+    agentDocs,
+    docker,
+    linter,
     help: Boolean(values.help),
     version: Boolean(values.version),
     positionals,
@@ -278,6 +381,11 @@ export function manifestToResponses(manifest, projectName) {
   const framework = normalizeFramework({ name: frameworkName, variant: frameworkVariant });
   const canClientRoute = isPromptVisible(framework, "router");
   const supportsBundler = isPromptVisible(framework, "bundler");
+  const supportsAdapter = isPromptVisible(framework, "adapter");
+  const supportsDatabase = isPromptVisible(framework, "database");
+  const supportsCompiler = isPromptVisible(framework, "reactCompiler");
+  const supportsRouteGroups = isPromptVisible(framework, "routeGroups");
+  const supportsDocker = isPromptVisible(framework, "docker");
 
   return {
     projectName,
@@ -287,7 +395,14 @@ export function manifestToResponses(manifest, projectName) {
       supportsBundler && manifest.framework?.bundler
         ? manifest.framework.bundler
         : undefined,
-    adapter: manifest.framework?.adapter,
+    adapter:
+      supportsAdapter && manifest.framework?.adapter
+        ? manifest.framework.adapter
+        : undefined,
+    database:
+      supportsDatabase && manifest.database?.orm
+        ? manifest.database.orm
+        : "none",
     architecture: manifest.architecture?.type || "feature-based",
     language: manifest.tooling?.language || "ts",
     cssFramework: manifest.styling?.engine || "tailwind",
@@ -295,10 +410,14 @@ export function manifestToResponses(manifest, projectName) {
     formatter: manifest.tooling?.formatter || "prettier",
     uiKit: manifest.ui?.kit || "none",
     docsLanguage: manifest.docs?.language || "en",
-    reactCompiler: manifest.reactCompiler,
+    reactCompiler: supportsCompiler ? manifest.reactCompiler : undefined,
+    routeGroups: supportsRouteGroups ? manifest.routeGroups : undefined,
     agentDocs: manifest.agentDocs,
-    // Sensible defaults for scaffolder conditional passes
-    testing: "vitest",
+    docker: supportsDocker ? (manifest.docker ?? false) : false,
+    // Sensible defaults for scaffolder conditional passes (Next.js ships no
+    // verified test-runner overlay yet, so it defaults to none; explicit
+    // vitest/jest selection still applies the standard overlays)
+    testing: frameworkName === "next" ? "none" : "vitest",
     router: canClientRoute,
     stateManagement: "none",
     iconLibrary: "none",
@@ -325,6 +444,9 @@ ${chalk.bold("OPTIONS")}
   ${chalk.yellow("-m, --manifest")} <path>  Drive scaffolding from a lumen.config.json or inline JSON
   ${chalk.yellow("-t, --template")} <name>  Scaffold using a preset (${Object.keys(PRESETS).join(", ")})
   ${chalk.yellow("-f, --framework")} <name> Target framework (react, next, react:vite, next:app-router, etc.)
+  ${chalk.yellow("--db, --database")} <orm> Database ORM (prisma, none)
+  ${chalk.yellow("    --docker")}           Include multi-stage Dockerfile & docker-compose for Next.js standalone
+  ${chalk.yellow("--route-groups")}         Include Next.js route groups preset (public, auth, private, admin)
   ${chalk.yellow("-h, --help")}             Show this help message
   ${chalk.yellow("-v, --version")}          Show version number
 
@@ -335,6 +457,10 @@ ${chalk.bold("PRESETS")}
   ${chalk.cyan("react-type-js")}  React + Vite + JavaScript (type-based)
   ${chalk.cyan("react-none-ts")}  React + Vite + TypeScript (none)
   ${chalk.cyan("react-none-js")}  React + Vite + JavaScript (none)
+  ${chalk.cyan("next-ts")}         Next.js App Router + TypeScript (feature-based)
+  ${chalk.cyan("next-js")}         Next.js App Router + JavaScript (feature-based)
+  ${chalk.cyan("next-pages-ts")}   Next.js Pages Router + TypeScript (feature-based)
+  ${chalk.cyan("next-pages-js")}   Next.js Pages Router + JavaScript (feature-based)
 
 ${chalk.bold("EXAMPLES")}
   ${chalk.gray("# Interactive setup")}

package/src/configure.js

@@ -166,12 +166,16 @@ async function configurePackageJson(projectPath, language) {
 
     if (!pkg.scripts) pkg.scripts = {};
 
-    pkg.scripts.dev = "vite";
-    pkg.scripts.build = "vite build";
-    pkg.scripts.preview = "vite preview";
+    // Fill defaults only — never overwrite scripts owned by the base template
+    // (Next.js bases ship next dev/build/start) or merged overlay fragments
+    // (e.g. the bundler-aware dev script). React/Vite bases already carry the
+    // vite commands, so this is a no-op there too.
+    pkg.scripts.dev ??= "vite";
+    pkg.scripts.build ??= "vite build";
+    pkg.scripts.preview ??= "vite preview";
 
     if (language === "ts") {
-      pkg.scripts.typecheck = "tsc -b";
+      pkg.scripts.typecheck ??= "tsc -b";
     }
 
     await fsp.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");