create-lumen 2.0.0-beta.1 → 2.0.0-beta.3

package/src/env.js

@@ -1,5 +1,6 @@
 import path from "path";
 import { promises as fsp } from "fs";
+import { normalizeFramework } from "./engine/capabilities.js";
 
 const ENV_GITIGNORE = `
 # Environment variables
@@ -8,13 +9,167 @@ const ENV_GITIGNORE = `
 !.env.example
 `;
 
-export async function copyEnvExample(projectPath, templatesDir) {
-  const src = path.join(templatesDir, ".env.example");
+export async function resolveFramework(projectPath, responses = {}) {
+  if (responses.framework || responses.frameworkName) {
+    return normalizeFramework(
+      responses.framework || {
+        name: responses.frameworkName,
+        variant: responses.frameworkVariant,
+      }
+    );
+  }
+
+  // Try reading lumen.config.json if already written
+  try {
+    const manifestPath = path.join(projectPath, "lumen.config.json");
+    const content = await fsp.readFile(manifestPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (parsed.framework) return normalizeFramework(parsed.framework);
+  } catch {}
+
+  // Try checking package.json
   try {
-    await fsp.access(src);
-    await fsp.copyFile(src, path.join(projectPath, ".env.example"));
+    const pkgPath = path.join(projectPath, "package.json");
+    const content = await fsp.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(content);
+    if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+      return { name: "next", variant: "app-router" };
+    }
   } catch {}
 
+  return { name: "react", variant: "vite" };
+}
+
+export function buildEnvExample(responses = {}, existingContent = "") {
+  const fw = normalizeFramework(
+    responses.framework || {
+      name: responses.frameworkName,
+      variant: responses.frameworkVariant,
+    }
+  );
+
+  const isNext = fw.name === "next";
+  const lines = [];
+
+  if (isNext) {
+    const routerDocs =
+      fw.variant === "pages-router"
+        ? "https://nextjs.org/docs/pages/building-your-application/configuring/environment-variables"
+        : "https://nextjs.org/docs/app/building-your-application/configuring/environment-variables";
+
+    lines.push("# Copy this file to `.env.local` (or `.env`) and fill in your values.");
+    lines.push(`# See ${routerDocs} for details.`);
+    lines.push("");
+
+    // Public API client URL
+    lines.push("# Public API URL (accessible in browser and server via process.env.NEXT_PUBLIC_API_URL)");
+    lines.push("NEXT_PUBLIC_API_URL=https://api.example.com");
+
+    // Database (Prisma)
+    if (responses.database === "prisma" || existingContent.includes("DATABASE_URL")) {
+      const isSupabase =
+        responses.databaseProvider === "supabase" ||
+        responses.dbProvider === "supabase" ||
+        (!responses.databaseProvider && existingContent.includes("pooler.supabase.com"));
+
+      lines.push("");
+      if (isSupabase) {
+        lines.push("# Database (Prisma + Supabase PostgreSQL)");
+        lines.push("# Transaction connection pooler (port 6543) with PgBouncer - used by Next.js Server Components / Actions:");
+        lines.push('DATABASE_URL="postgresql://postgres.[YOUR-PROJECT-REF]:[YOUR-PASSWORD]@aws-0-[REGION].pooler.supabase.com:6543/postgres?pgbouncer=true"');
+        lines.push("");
+        lines.push("# Direct connection (port 5432) - used by Prisma CLI for migrations:");
+        lines.push('DIRECT_URL="postgresql://postgres.[YOUR-PROJECT-REF]:[YOUR-PASSWORD]@aws-0-[REGION].pooler.supabase.com:5432/postgres"');
+        lines.push("");
+        lines.push("# Local development fallback (local PostgreSQL / Docker compose / Supabase local CLI):");
+        lines.push('# DATABASE_URL="postgresql://postgres:postgres@localhost:5432/app?schema=public"');
+        lines.push('# DIRECT_URL="postgresql://postgres:postgres@localhost:5432/app?schema=public"');
+        lines.push("");
+        lines.push("# Supabase API credentials (optional, for Supabase Auth / Storage)");
+        lines.push('# NEXT_PUBLIC_SUPABASE_URL="https://[YOUR-PROJECT-REF].supabase.co"');
+        lines.push('# NEXT_PUBLIC_SUPABASE_ANON_KEY="eyJhbGciOi..."');
+      } else {
+        lines.push("# Database (Prisma + PostgreSQL)");
+        lines.push("# Local development with PostgreSQL or Docker compose (docker compose up -d db):");
+        lines.push('DATABASE_URL="postgresql://postgres:postgres@localhost:5432/app?schema=public"');
+        lines.push('DIRECT_URL="postgresql://postgres:postgres@localhost:5432/app?schema=public"');
+        lines.push("");
+        lines.push("# Supabase / cloud PostgreSQL with connection pooling (Transaction mode / port 6543):");
+        lines.push('# DATABASE_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:6543/postgres?pgbouncer=true"');
+        lines.push('# DIRECT_URL="postgresql://postgres:[YOUR-PASSWORD]@db.[YOUR-PROJECT-REF].supabase.co:5432/postgres"');
+      }
+    }
+
+    // Docker
+    if (responses.docker === true || existingContent.includes("PORT=")) {
+      lines.push("");
+      lines.push("# Server / Container Port (optional, defaults to 3000)");
+      lines.push("# PORT=3000");
+    }
+  } else {
+    // React / Vite
+    lines.push("# Copy this file to `.env.local` (or `.env`) and fill in your values.");
+    lines.push("# See https://vite.dev/guide/env-and-mode for how env vars are exposed.");
+    lines.push("");
+    lines.push("# Application API URL (accessible in Vite via import.meta.env.VITE_API_URL)");
+    lines.push("VITE_API_URL=https://api.example.com");
+  }
+
+  lines.push("");
+  let result = lines.join("\n");
+
+  // If there was existing custom content, preserve custom non-framework variables
+  if (existingContent && existingContent.trim()) {
+    const existingLines = existingContent.split("\n");
+    const preservedLines = [];
+    for (const line of existingLines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+
+      // Purge Vite references from Next.js scaffolds
+      if (
+        isNext &&
+        (trimmed.startsWith("VITE_") ||
+          trimmed.includes("vitejs.dev") ||
+          trimmed.includes("vite.dev"))
+      ) {
+        continue;
+      }
+      // Purge Next.js references from React scaffolds
+      if (!isNext && trimmed.startsWith("NEXT_PUBLIC_")) {
+        continue;
+      }
+
+      // Check variable name
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx !== -1) {
+        const varName = trimmed.slice(0, eqIdx).trim();
+        if (!result.includes(varName + "=")) {
+          preservedLines.push(line);
+        }
+      }
+    }
+    if (preservedLines.length > 0) {
+      result = result.trimEnd() + "\n\n# Custom environment variables\n" + preservedLines.join("\n") + "\n";
+    }
+  }
+
+  return result;
+}
+
+export async function copyEnvExample(projectPath, templatesDir, responses = {}) {
+  const fw = await resolveFramework(projectPath, responses);
+  const resolvedResponses = { ...responses, framework: fw };
+
+  const envPath = path.join(projectPath, ".env.example");
+  let existingContent = "";
+  try {
+    existingContent = await fsp.readFile(envPath, "utf8");
+  } catch {}
+
+  const envContent = buildEnvExample(resolvedResponses, existingContent);
+  await fsp.writeFile(envPath, envContent, "utf8");
+
   // Ensure the project gitignore excludes env files but keeps .env.example.
   const gitignore = path.join(projectPath, ".gitignore");
   try {

package/src/format.js

@@ -17,12 +17,20 @@ async function exists(p) {
 // is already on PATH (e.g. verification harnesses resolving from a vendored
 // node_modules symlink).
 export async function runProjectFormat(projectPath, responses) {
-  if (!responses.formatter || responses.formatter === "none") return;
+  if (responses.formatter && responses.formatter !== "none") {
+    const formatter = responses.formatter;
+    const bin = path.join(projectPath, "node_modules", ".bin", formatter);
+    const command = (await exists(bin)) ? bin : formatter;
+    const args = formatter === "prettier" ? ["--write", "."] : ["."];
 
-  const formatter = responses.formatter;
-  const bin = path.join(projectPath, "node_modules", ".bin", formatter);
-  const command = (await exists(bin)) ? bin : formatter;
-  const args = formatter === "prettier" ? ["--write", "."] : ["."];
+    await execa(command, args, { cwd: projectPath, stdio: "pipe" });
+    return;
+  }
 
-  await execa(command, args, { cwd: projectPath, stdio: "pipe" });
+  // When Biome is the linter and no separate formatter is chosen, use Biome's native check --write
+  if (responses.linter === "biome") {
+    const bin = path.join(projectPath, "node_modules", ".bin", "biome");
+    const command = (await exists(bin)) ? bin : "biome";
+    await execa(command, ["check", "--write", "."], { cwd: projectPath, stdio: "pipe" });
+  }
 }

package/src/injector.js

@@ -1,5 +1,6 @@
 import { promises as fsp } from "fs";
 import path from "path";
+import { normalizeFramework } from "./engine/capabilities.js";
 import {
   FRAGMENT_SCOPES,
   resolveFragments,
@@ -31,9 +32,25 @@ export async function injectArchitecture(
   templatesDir,
   architecture,
   language,
-  cssFramework
+  cssFramework,
+  frameworkOptions = {}
 ) {
-  const responses = { architecture, language, cssFramework };
+  const fwObj =
+    typeof frameworkOptions === "object" && frameworkOptions !== null
+      ? frameworkOptions
+      : typeof frameworkOptions === "string"
+      ? { name: frameworkOptions }
+      : {};
+  const framework = normalizeFramework(fwObj);
+  const responses = {
+    architecture,
+    language,
+    cssFramework,
+    framework,
+    frameworkName: framework.name,
+    frameworkVariant: framework.variant,
+    ...fwObj,
+  };
   const allFragments = resolveFragments(responses, templatesDir);
   const archFragments = allFragments.filter(
     (f) =>
@@ -150,35 +167,59 @@ export function getComponentsJson({
   architecture = "feature-based",
   language = "ts",
 }) {
-  const isNext = framework === "next";
+  const fwName =
+    typeof framework === "object" && framework !== null
+      ? framework.name
+      : String(framework);
+  const fwVariant =
+    typeof framework === "object" && framework !== null
+      ? framework.variant
+      : "app-router";
+  const isNext = fwName === "next";
   const isTs = language === "ts";
+  const isFeatureBased = architecture === "feature-based";
 
   if (isNext) {
+    const cssPath =
+      fwVariant === "pages-router"
+        ? "src/styles/globals.css"
+        : "src/app/globals.css";
+
     // Next App Router contract stub
     return {
       $schema: "https://ui.shadcn.com/schema.json",
       style: "new-york",
-      rsc: true,
+      rsc: fwVariant !== "pages-router",
       tsx: isTs,
       tailwind: {
         config: "",
-        css: "app/globals.css",
+        css: cssPath,
         baseColor: "neutral",
         cssVariables: true,
         prefix: "",
       },
-      aliases: {
-        components: "@/components",
-        utils: "@/lib/utils",
-        ui: "@/components/ui",
-        lib: "@/lib",
-        hooks: "@/hooks",
-      },
+      aliases: isFeatureBased
+        ? {
+            components: "@/shared/components",
+            utils: "@/lib/utils",
+            ui: "@/shared/components/ui",
+            lib: "@/lib",
+            hooks: "@/shared/hooks",
+          }
+        : {
+            components: "@/components",
+            utils: "@/lib/utils",
+            ui: "@/components/ui",
+            lib: "@/lib",
+            hooks: "@/hooks",
+          },
       iconLibrary: "lucide",
+      registries: {
+        "@lumen": "https://raw.githubusercontent.com/strophix-software/lumen-registry/main/public/r",
+      },
     };
   }
 
-  const isFeatureBased = architecture === "feature-based";
   return {
     $schema: "https://ui.shadcn.com/schema.json",
     style: "new-york",
@@ -209,6 +250,9 @@ export function getComponentsJson({
           hooks: "@/hooks",
         },
     iconLibrary: "lucide",
+    registries: {
+      "@lumen": "https://raw.githubusercontent.com/strophix-software/lumen-registry/main/public/r",
+    },
   };
 }
 
@@ -232,6 +276,7 @@ export async function injectUiKit(
   const codeExt = isTs ? "tsx" : "jsx";
   const utilExt = isTs ? "ts" : "js";
   const framework = responses.framework || responses.frameworkName || "vite";
+  const isNext = typeof framework === "object" ? framework.name === "next" : framework === "next";
 
   // 1. Write components.json
   const componentsJson = getComponentsJson({
@@ -313,7 +358,14 @@ export async function injectUiKit(
 
   try {
     await fsp.access(buttonTemplate);
-    await fsp.copyFile(buttonTemplate, buttonDest);
+    let buttonContent = await fsp.readFile(buttonTemplate, "utf8");
+    if (isNext) {
+      buttonContent = buttonContent.replace(
+        /\/\/ eslint-disable-next-line react-refresh\/only-export-components\r?\n/,
+        ""
+      );
+    }
+    await fsp.writeFile(buttonDest, buttonContent, "utf8");
   } catch {}
 
   try {

package/src/main.js

@@ -26,9 +26,9 @@ import { normalizeFramework } from "@/engine/capabilities.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const TEMPLATES_DIR = path.join(__dirname, "../templates");
-const CURRENT_DIR = process.cwd();
 
-export function resolveProjectName({ quickSetup = false, projectName: nameArg, cwd = CURRENT_DIR, rawArgs } = {}) {
+export function resolveProjectName({ quickSetup = false, projectName: nameArg, cwd, rawArgs } = {}) {
+  const currentDir = cwd || process.cwd();
   const cli = parseCliArgs(rawArgs || process.argv.slice(2));
   const cliArg = nameArg || cli.projectName || null;
 
@@ -37,7 +37,7 @@ export function resolveProjectName({ quickSetup = false, projectName: nameArg, c
   }
 
   if (quickSetup || cli.quickSetup || cli.manifest || cli.template) {
-    const defaultName = path.basename(cwd).trim() || "my-app";
+    const defaultName = path.basename(currentDir).trim() || "my-app";
     return defaultName === "." ? "my-app" : defaultName;
   }
 
@@ -52,16 +52,31 @@ export async function main(options = {}) {
     template: templateName,
     framework: frameworkArg,
     arch: archArg,
+    language: languageArg,
+    cssFramework: cssArg,
+    uiKit: uiKitArg,
+    database: databaseArg,
+    databaseProvider: dbProviderArg,
+    docker: dockerArg,
+    testing: testingArg,
+    linter: linterArg,
+    formatter: formatterArg,
+    routeGroups: routeGroupsArg,
+    bundler: bundlerArg,
+    adapter: adapterArg,
+    reactCompiler: reactCompilerArg,
+    agentDocs: agentDocsArg,
   } = options;
   const pkg = getPkgManager();
 
   const isNonInteractive = Boolean(quickSetup || manifestSource || templateName);
+  const currentDir = options.cwd || process.cwd();
 
   // 1. Project name
   let projectName = resolveProjectName({
     quickSetup: isNonInteractive,
     projectName: nameArg,
-    cwd: CURRENT_DIR,
+    cwd: currentDir,
   });
 
   if (projectName) {
@@ -83,7 +98,7 @@ export async function main(options = {}) {
   // 3. Collect user preferences (interactive or non-interactive)
   let responses;
   if (manifestSource) {
-    const manifestObj = loadManifestSource(manifestSource, CURRENT_DIR);
+    const manifestObj = loadManifestSource(manifestSource, currentDir);
     responses = manifestToResponses(manifestObj, projectName);
   } else if (templateName) {
     const preset = PRESETS[templateName];
@@ -100,7 +115,23 @@ export async function main(options = {}) {
     responses = await getUserInputs(projectName, { quickSetup, initialArch: archArg, framework: frameworkArg });
   }
 
-  const projectPath = path.resolve(CURRENT_DIR, projectName);
+  // Overlay explicit CLI flags if provided
+  if (languageArg) responses.language = languageArg;
+  if (cssArg) responses.cssFramework = cssArg;
+  if (uiKitArg) responses.uiKit = uiKitArg;
+  if (linterArg) responses.linter = linterArg;
+  if (formatterArg) responses.formatter = formatterArg;
+  if (databaseArg) responses.database = databaseArg;
+  if (dbProviderArg) responses.databaseProvider = dbProviderArg;
+  if (testingArg) responses.testing = testingArg;
+  if (dockerArg) responses.docker = true;
+  if (routeGroupsArg) responses.routeGroups = true;
+  if (bundlerArg) responses.bundler = bundlerArg;
+  if (adapterArg) responses.adapter = adapterArg;
+  if (reactCompilerArg !== null && reactCompilerArg !== undefined) responses.reactCompiler = reactCompilerArg;
+  if (agentDocsArg !== null && agentDocsArg !== undefined) responses.agentDocs = agentDocsArg;
+
+  const projectPath = path.resolve(currentDir, projectName);
 
   // 4. Scaffold the base project (provider-owned bases; Vite shells out, Next copies)
   const fw = normalizeFramework(
@@ -168,7 +199,8 @@ export async function main(options = {}) {
       TEMPLATES_DIR,
       responses.architecture,
       responses.language,
-      responses.cssFramework
+      responses.cssFramework,
+      responses.framework || { name: responses.frameworkName, variant: responses.frameworkVariant }
     );
     archSpin.stop(chalk.green("Architecture scaffolding complete."));
   } catch (err) {
@@ -233,6 +265,7 @@ export async function main(options = {}) {
       architecture: responses.architecture,
       ext: responses.language === "ts" ? "tsx" : "jsx",
       pkg,
+      framework: responses.framework || { name: responses.frameworkName, variant: responses.frameworkVariant },
     });
     if (responses.cssFramework !== "none") {
       cssSpin.stop(chalk.green(`${cssLabel} setup complete.`));
@@ -246,7 +279,12 @@ export async function main(options = {}) {
   const configSpin = spinner();
   configSpin.start("Configuring project...");
   try {
-    await configureProject(projectPath, responses.language, responses.cssFramework);
+    await configureProject(
+      projectPath,
+      responses.language,
+      responses.cssFramework,
+      responses.framework || { name: responses.frameworkName, variant: responses.frameworkVariant }
+    );
     configSpin.stop(chalk.green("Project configured."));
   } catch (err) {
     configSpin.stop(chalk.red("Failed to configure project."));
@@ -254,10 +292,10 @@ export async function main(options = {}) {
   }
 
   // 12. Cleanup boilerplate
-  await cleanupBoilerplate(projectPath);
+  await cleanupBoilerplate(projectPath, responses);
 
   // 12.5 Copy .env.example into the project
-  await copyEnvExample(projectPath, TEMPLATES_DIR);
+  await copyEnvExample(projectPath, TEMPLATES_DIR, responses);
 
   // 12.6 Emit lumen.config.json (manifest v2) — byte-deterministic, Zod-validated
   const manifestSpin = spinner();
@@ -270,15 +308,15 @@ export async function main(options = {}) {
     throw err;
   }
 
-  // 12.7 Emit .lumen agent context dir (only when agentDocs is enabled)
+  // 12.7 Emit AGENTS.md at root (only when agentDocs is enabled)
   if (responses.agentDocs === true || responses._manifestSource?.agentDocs === true) {
     const agentSpin = spinner();
-    agentSpin.start("Writing .lumen agent context...");
+    agentSpin.start("Writing AGENTS.md...");
     try {
       await emitAgentContext(projectPath, responses._manifestSource ?? responses);
-      agentSpin.stop(chalk.green(".lumen agent context written."));
+      agentSpin.stop(chalk.green("AGENTS.md written."));
     } catch (err) {
-      agentSpin.stop(chalk.red("Failed to write .lumen agent context."));
+      agentSpin.stop(chalk.red("Failed to write AGENTS.md."));
       throw err;
     }
   }
@@ -297,9 +335,16 @@ export async function main(options = {}) {
   }
 
   // 13.5 Format the freshly generated project so it is canonical on init
-  if (responses.formatter && responses.formatter !== "none") {
+  const shouldFormat =
+    (responses.formatter && responses.formatter !== "none") ||
+    responses.linter === "biome";
+  if (shouldFormat) {
+    const fmtName =
+      responses.formatter && responses.formatter !== "none"
+        ? responses.formatter
+        : "biome";
     const fmtPassSpin = spinner();
-    fmtPassSpin.start(`Formatting project with ${responses.formatter}...`);
+    fmtPassSpin.start(`Formatting project with ${fmtName}...`);
     try {
       await runProjectFormat(projectPath, responses);
       fmtPassSpin.stop(chalk.green("Project formatted."));
@@ -317,5 +362,5 @@ export async function main(options = {}) {
   );
 
   // 14. Offer dev server
-  await handleDevServer(pkg, projectName);
+  await handleDevServer(pkg, projectName, { isNonInteractive });
 }

package/src/manifest/emit.js

@@ -15,25 +15,34 @@ const FORMAT_COMMANDS = {
 };
 
 /**
- * Build default harness commands from tooling choices.
+ * Build default harness commands from tooling choices and test framework.
  * Skips lint/format when tooling is "none"; skips types when language is not "ts".
- * Test + build are always included so commands.length >= 1.
- * @param {{ linter?: string, formatter?: string, language?: string }} tooling
+ * Skips test when testing is "none" (or not configured).
+ * Build is always included so commands.length >= 1.
+ * @param {{ linter?: string, formatter?: string, language?: string, testing?: string }} tooling
+ * @param {string} [testing]
  * @returns {Array<{ name: string, command: string, required: boolean }>}
  */
-export function defaultHarnessCommands(tooling = {}) {
+export function defaultHarnessCommands(tooling = {}, testing = null) {
   const { linter = "none", formatter = "none", language = "ts" } = tooling;
+  const testFramework = testing ?? tooling.testing ?? "none";
   const commands = [];
   if (linter && linter !== "none" && LINT_COMMANDS[linter]) {
     commands.push({ name: "lint", command: LINT_COMMANDS[linter], required: true });
   }
   if (formatter && formatter !== "none" && FORMAT_COMMANDS[formatter]) {
     commands.push({ name: "format", command: FORMAT_COMMANDS[formatter], required: true });
+  } else if (linter === "biome" && (!formatter || formatter === "none" || formatter === "biome")) {
+    commands.push({ name: "format", command: "biome check --write .", required: true });
   }
   if (language === "ts") {
     commands.push({ name: "types", command: "tsc -b", required: true });
   }
-  commands.push({ name: "test", command: "vitest run", required: true });
+  if (testFramework === "vitest") {
+    commands.push({ name: "test", command: "vitest run", required: true });
+  } else if (testFramework === "jest") {
+    commands.push({ name: "test", command: "npm test", required: true });
+  }
   commands.push({ name: "build", command: "npm run build", required: true });
   return commands.length > 0 ? commands : [...HARNESS_DEFAULT_COMMANDS];
 }
@@ -99,8 +108,15 @@ export function buildManifest(responses, opts = {}) {
     formatter: responses.formatter || "none",
   };
 
+  const resolvedTesting =
+    responses.testing !== undefined
+      ? responses.testing
+      : framework.name === "next"
+      ? "none"
+      : "vitest";
+
   const harness = responses.harness ?? {
-    commands: defaultHarnessCommands(tooling),
+    commands: defaultHarnessCommands(tooling, resolvedTesting),
   };
 
   const manifest = {
@@ -117,8 +133,18 @@ export function buildManifest(responses, opts = {}) {
   };
 
   // Optional cross-cutting flags — only include if explicitly set (keeps minimal manifest byte-stable)
+  if (responses.database && responses.database !== "none") {
+    manifest.database = {
+      orm: responses.database,
+      provider: responses.databaseProvider || "postgresql",
+    };
+  }
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.reactCompiler === "boolean") manifest.reactCompiler = responses.reactCompiler;
+  if (typeof responses.routeGroups === "boolean") manifest.routeGroups = responses.routeGroups;
   if (typeof responses.agentDocs === "boolean") manifest.agentDocs = responses.agentDocs;
+  if (typeof responses.docker === "boolean") manifest.docker = responses.docker;
 
   // Enforce stable top-level key order for determinism (like formatter pass)
   const ordered = {};
@@ -133,6 +159,9 @@ export function buildManifest(responses, opts = {}) {
     "docs",
     "paths",
     "tooling",
+    "database",
+    "docker",
+    "routeGroups",
     "reactCompiler",
     "agentDocs",
   ];

package/src/manifest/paths.js

@@ -16,7 +16,7 @@ export function resolvePaths({ architecture, framework = {} } = {}) {
   const variant = framework.variant || (fwName === "next" ? "app-router" : "vite");
 
   // Helper to pick Next.js pages root based on variant
-  const nextPagesForVariant = (v) => (v === "pages-router" ? "pages" : "app");
+  const nextPagesForVariant = (v) => (v === "pages-router" ? "src/pages" : "src/app");
   const isNext = fwName === "next";
 
   // -- feature-based (React + Vite canonical, also Next feature-based)
@@ -69,30 +69,6 @@ export function resolvePaths({ architecture, framework = {} } = {}) {
     };
   }
 
-  // -- hybrid (Next.js: feature + shared). For React, fallback to feature-based
-  if (arch === "hybrid") {
-    if (isNext) {
-      const nextRoot = nextPagesForVariant(variant);
-      return {
-        features: "src/features",
-        components: "src/shared/components",
-        services: "src/shared/services",
-        hooks: "src/shared/hooks",
-        pages: nextRoot,
-        ui: "src/shared/components/ui",
-      };
-    }
-    // React hybrid = hybrid not valid, but map to feature-based for determinism
-    return {
-      features: "src/features",
-      components: "src/shared/components",
-      services: "src/shared/services",
-      hooks: "src/shared/hooks",
-      pages: "src/app/router",
-      ui: "src/shared/components/ui",
-    };
-  }
-
   // -- none (minimal flat src/ — no imposed convention)
   if (arch === "none") {
     if (isNext) {