project-auto-wizard 0.14.0 → 0.15.1

package/payload/workflows/spring/server-deploy/PROJECT-SPRING-SIMPLE-CICD.yaml

@@ -132,6 +132,7 @@ jobs:
           SSH_KEY: ${{ secrets.SSH_KEY }}
           DOCKERFILE: ${{ env.DOCKERFILE_PATH }}
         run: |
+          [ -f "$GITHUB_WORKSPACE/.github/scripts/messages.py" ] || { echo "::error::messages.py is missing; rerun \`npx project-auto-wizard --mode full --force\`"; exit 1; }
           m() { python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" get "$@"; }
           MISSING=""
           for NAME in DOCKERHUB_USERNAME DOCKERHUB_TOKEN SERVER_HOST SERVER_USER; do
@@ -172,6 +173,7 @@ jobs:
       # write it to a file in the resources directory
       - name: Generate application-prod.yml
         run: |
+          [ -f "$GITHUB_WORKSPACE/.github/scripts/messages.py" ] || { echo "::error::messages.py is missing; rerun \`npx project-auto-wizard --mode full --force\`"; exit 1; }
           m() { python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" get "$@"; }
           mkdir -p ${{ env.APPLICATION_YML_DIR }}
 
@@ -187,10 +189,10 @@ jobs:
         run: ./gradlew clean build -x test ${{ env.GRADLE_OPTS }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
 
       - name: Log in to DockerHub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
@@ -205,7 +207,7 @@ jobs:
 
       # Use the branch name as the image tag to manage images per environment
       - name: Build and push Docker image
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v7
         with:
           context: ${{ env.PROJECT_PATH }}
           file: ${{ env.PROJECT_PATH }}/${{ env.DOCKERFILE_PATH }}
@@ -238,6 +240,7 @@ jobs:
 
       - name: Load messages
         run: |
+          [ -f "$GITHUB_WORKSPACE/.github/scripts/messages.py" ] || { echo "::error::messages.py is missing; rerun \`npx project-auto-wizard --mode full --force\`"; exit 1; }
           MSGS="$(python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" dump wf_spring_deploy. \
             | python3 -c 'import json, shlex, sys; d = json.load(sys.stdin); print("\n".join("M_%s=%s" % (k.replace(".", "_"), shlex.quote(v)) for k, v in d.items()))' \
             | base64 | tr -d '\n')"
@@ -429,7 +432,7 @@ jobs:
             m simple_summary_branch branch="$BRANCH"
             m simple_summary_container name="$CONTAINER_NAME"
             m simple_summary_port port="$PORT"
-            m simple_summary_time time="$(date '+%Y-%m-%d %H:%M:%S')"
+            m simple_summary_time time="$(date -u '+%Y-%m-%d %H:%M:%S UTC')"
             echo ""
             m simple_access_url url="http://${{ secrets.SERVER_HOST }}:${PORT}"
 

package/src/cli/args.js

@@ -2,7 +2,7 @@
 import { VALID_TYPES, VALID_MODES } from "../context.js";
 import { DEPLOY_STYLES, isDeployStyle, NO_DEPLOY_STYLE } from "../core/deploy-style.js";
 import { isValidBranchName } from "../core/branches.js";
-import { TYPES } from "../core/types.js";
+import { TYPES, canonicalTypeId } from "../core/types.js";
 import { CliError } from "../core/errors.js";
 import { normalizePath, isRepoRelativePath } from "../core/paths.js";
 import { t, DEFAULT_LANGUAGE, SUPPORTED_LANGUAGES, isSupportedLanguage, normalizeLanguage } from "../i18n/index.js";
@@ -108,12 +108,15 @@ export function parseArgs(argv) {
         for (let name of csv.split(",")) {
           name = name.replace(/\s/g, "");
           if (name === "") continue;
-          if (seen.has(name)) continue;      // dedup
-          if (!VALID_TYPES.includes(name)) {
+          // The alias is resolved here, before validation and dedup (--type react,next is just react).
+          // Only registry ids are valid, so an unsupported name is reported as typed.
+          const id = canonicalTypeId(name);
+          if (seen.has(id)) continue;      // dedup
+          if (!VALID_TYPES.includes(id)) {
             throw new CliError(t("cli.args.typeUnsupported", { type: name, valid: VALID_TYPES.join(" ") }));
           }
-          seen.add(name);
-          types.push(name);
+          seen.add(id);
+          types.push(id);
         }
         if (types.length === 0) throw new CliError(t("cli.args.typeEmpty"));
         result.types = types;
@@ -193,20 +196,27 @@ export function parseArgs(argv) {
 // "flutter=app,react=client" -> Map<type, normalizedPath>. Validates types (invalid -> throw).
 export function parsePathsCsv(csv) {
   const map = new Map();
+  const spelled = new Map(); // type -> name as typed, to tell an alias clash from a plain repeat
   if (!csv) return map;
   for (const pair of csv.split(",")) {
     if (pair.trim() === "") continue;
     const eq = pair.indexOf("=");
-    const type = (eq >= 0 ? pair.slice(0, eq) : pair).replace(/\s/g, "");
+    const typeRaw = (eq >= 0 ? pair.slice(0, eq) : pair).replace(/\s/g, "");
+    const type = canonicalTypeId(typeRaw);
     const rawPath = eq >= 0 ? pair.slice(eq + 1) : "";
     if (!VALID_TYPES.includes(type)) {
-      throw new CliError(t("cli.args.pathsTypeUnsupported", { type }));
+      throw new CliError(t("cli.args.pathsTypeUnsupported", { type: typeRaw }));
     }
     const path = normalizePath(rawPath);
     if (!isRepoRelativePath(path)) {
       throw new CliError(t("cli.args.pathsRelativeOnly", { pair: `${type}=${rawPath.trim()}` }));
     }
+    // An alias and its canonical name in one list (react=a,next=b) would silently drop a folder; refuse it instead.
+    if (map.has(type) && spelled.get(type) !== typeRaw && map.get(type) !== path) {
+      throw new CliError(t("cli.args.pathsDuplicateType", { type }));
+    }
     map.set(type, path);
+    spelled.set(type, typeRaw);
   }
   return map;
 }

package/src/commands/doctor.js

@@ -14,6 +14,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { A, paint, colorEnabled, visualWidth } from "../ui/ansi.js";
 import { PATHS } from "../core/paths.js";
+import { findMissingScripts } from "../core/copy/simple.js";
+import { resolvePayloadRoot } from "../core/assets.js";
 import { parseExisting } from "../core/version-yml.js";
 import { hooksFor } from "../core/types.js";
 import { t } from "../i18n/index.js";
@@ -44,6 +46,15 @@ export function runDoctor(cwd = process.cwd(), { exec = defaultExec } = {}) {
   // Per-type local file checks (e.g. Flutter store deploy files): only local files are read, so this runs regardless of the gh lookup results.
   if (installed) {
     const existing = parseExisting(readFileSync(join(cwd, PATHS.versionFile), "utf8"));
+    const missing = findMissingScripts(resolvePayloadRoot(), cwd);
+    if (missing.length) {
+      add({
+        name: t("cmd.doctor.scripts.name"), label: t("cmd.doctor.scripts.label"), purpose: t("cmd.doctor.scripts.purpose"), status: "WARN",
+        value: t("cmd.doctor.scripts.missing", { files: missing.join(", ") }),
+        impact: [t("cmd.doctor.scripts.impact")],
+        actions: [t("cmd.doctor.scripts.action")],
+      });
+    }
     for (const { hook } of hooksFor(existing.types, "doctorChecks")) {
       for (const item of hook(cwd, existing, { docs: DOC })) add(item);
     }
@@ -179,6 +190,11 @@ export function runDoctor(cwd = process.cwd(), { exec = defaultExec } = {}) {
   return results;
 }
 
+// Exit code for the CLI: 0 when every item is OK/INFO, 1 when any WARN or FAIL item was found.
+// Warnings and errors are not split: both mean "something the workflows rely on needs attention",
+// and a script that wants to tolerate warnings can ignore the code (`|| true`).
+export const doctorExitCode = (results) => (results.some((r) => r.status === "WARN" || r.status === "FAIL") ? 1 : 0);
+
 const asLines = (v) => (Array.isArray(v) ? v : v ? [String(v)] : []);
 const headOf = (r) => `${r.label || r.name}${r.purpose ? ` — ${r.purpose}` : ""}`;
 

package/src/commands/dry-run.js

@@ -6,7 +6,7 @@ import { PATHS } from "../core/paths.js";
 import { planWorkflows } from "../core/copy/workflows.js";
 import { planTypeAppFiles } from "../core/copy/app-files.js";
 import { planUninstall } from "./uninstall.js";
-import { renderVersionYml, parseExisting, sameIgnoringTimestamps } from "../core/version-yml.js";
+import { renderVersionYml, parseExisting, sameIgnoringTimestamps, droppedPathLines } from "../core/version-yml.js";
 import { readVersionYmlTemplate } from "../core/assets.js";
 import { existingMarkerInDir } from "../core/paths-resolve.js";
 import { planScripts } from "../core/copy/simple.js";
@@ -33,6 +33,11 @@ function versionYmlPreview(context, payloadRoot, targetRoot) {
   return { existed: existingRaw !== null, changed: existingRaw === null || !sameIgnoringTimestamps(existingRaw, wouldBe) };
 }
 
+function existingDroppedLines(targetRoot, paths) {
+  const vyPath = join(targetRoot, PATHS.versionFile);
+  return existsSync(vyPath) ? droppedPathLines(parseExisting(readFileSync(vyPath, "utf8")).droppedPaths, paths) : [];
+}
+
 // mode: "full" | "uninstall". Read-only: writes no file.
 export function planDryRun(mode, context, payloadRoot, targetRoot = ".") {
   if (mode === "uninstall") {
@@ -54,6 +59,8 @@ export function planDryRun(mode, context, payloadRoot, targetRoot = ".") {
     // Flutter store deploy files (Fastfile, ExportOptions.plist): existing files are kept, not overwritten.
     flutterApp: planTypeAppFiles(context, payloadRoot, targetRoot),
     versionYml: versionYmlPreview(context, payloadRoot, targetRoot),
+    // Folders the rewrite would drop from version.yml (same type listed under two names with different folders).
+    droppedPathLines: existingDroppedLines(targetRoot, context.paths),
     // Files the real install also changes; scripts that overwrite existing files in particular must be shown in advance.
     scripts: planScripts(payloadRoot, targetRoot),
     readme: planVersionSection(targetRoot),
@@ -130,6 +137,7 @@ export function printDryRun(plan) {
       // For types with a deploy block (spring etc.) say the preview may differ from the real install.
       lines.push(t("cmd.dryRun.versionYml.note"));
     }
+    if (plan.droppedPathLines?.length) lines.push(...plan.droppedPathLines.map((l) => `⚠️  ${l}`));
     if (plan.scripts) {
       const mark = { create: "+", overwrite: "~", unchanged: "=" };
       const note = {
@@ -144,6 +152,7 @@ export function printDryRun(plan) {
         "skip-no-readme": t("cmd.dryRun.readme.skipNoReadme"),
         "skip-marker": t("cmd.dryRun.readme.skipMarker"),
         "skip-version-line": t("cmd.dryRun.readme.skipVersionLine"),
+        "heading-updated": t("cmd.dryRun.readme.headingUpdated"),
       }[plan.readme] || t("cmd.dryRun.readme.other", { status: plan.readme }));
     }
     if (plan.baselineExists !== undefined) {

package/src/commands/full.js

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { writeText, findUnwritable } from "../core/fsutil.js";
 import { CliError } from "../core/errors.js";
 import { PATHS } from "../core/paths.js";
-import { renderVersionYml, parseExisting, sameIgnoringTimestamps } from "../core/version-yml.js";
+import { renderVersionYml, parseExisting, sameIgnoringTimestamps, droppedPathLines } from "../core/version-yml.js";
 import { readVersionYmlTemplate } from "../core/assets.js";
 import { existingMarkerInDir } from "../core/paths-resolve.js";
 import { addVersionSectionToReadme, README_STATUS_LABEL } from "../core/copy/readme.js";
@@ -70,7 +70,10 @@ export function runFull(context, payloadRoot, targetRoot = ".", hooks = {}) {
   // Preserve unknown top-level fields of an existing version.yml when regenerating it.
   const vyPath = join(targetRoot, PATHS.versionFile);
   const prevVy = existsSync(vyPath) ? readFileSync(vyPath, "utf8") : null;
-  const extraTopLevel = prevVy != null ? parseExisting(prevVy).extraTopLevel : [];
+  const prevParsed = prevVy != null ? parseExisting(prevVy) : null;
+  const extraTopLevel = prevParsed ? prevParsed.extraTopLevel : [];
+  // Folders folded into one type entry are not managed after this rewrite; leave a trace in the install log.
+  for (const line of droppedPathLines(prevParsed?.droppedPaths, paths)) log.warn("version", "paths", line);
 
   // 2. Generate version.yml (render payload/version.yml.template; full regeneration)
   //    A re-run where only the date lines differ does not rewrite it (idempotent).

package/src/commands/interactive.js

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { resolvePayloadRoot, assertPayload, readTemplateVersion } from "../core/assets.js";
 import { detectTypes, detectVersion, detectDefaultBranch, detectRepoName, makeResolvers, detectMarkers } from "../core/detect-fs.js";
-import { parseExisting } from "../core/version-yml.js";
+import { parseExisting, droppedPathLines } from "../core/version-yml.js";
 import { pickReleaseOptions, resolveReleaseOptions } from "../core/release-options.js";
 import { runBreakingCheck } from "../core/breaking-check.js";
 import { resolveProjectPaths } from "../core/paths-resolve.js";
@@ -294,6 +294,9 @@ export async function runInteractive(baseCtx, { cwd = process.cwd(), payloadRoot
     for (const ty of types) if (ty !== "basic" && !paths.has(ty)) paths.set(ty, existing?.paths.get(ty) || ".");
   }
 
+  // Announce merged folders only now: the message must follow the folders actually chosen, not the saved ones.
+  if (existing?.droppedPaths?.length) io.note?.(droppedPathLines(existing.droppedPaths, paths).join("\n"), t("core.versionYml.pathMergedTitle"));
+
   // In a monorepo the version/build-number files live inside the type folder - detect there now that paths are settled.
   if (versionAutoDetected && [...paths.values()].some((p) => p && p !== ".")) {
     version = detectVersion(cwd, { types, paths, warn: () => {} });

package/src/commands/status.js

@@ -1,11 +1,12 @@
 // status command: read-only install state check. No network access (local file comparison only).
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { parseExisting } from "../core/version-yml.js";
+import { parseExisting, droppedPathLines } from "../core/version-yml.js";
 import { planWorkflows } from "../core/copy/workflows.js";
 import { makeResolvers, detectRepoName, detectDefaultBranch } from "../core/detect-fs.js";
 import { PATHS } from "../core/paths.js";
 import { isDeployStyle, DEFAULT_DEPLOY_STYLE } from "../core/deploy-style.js";
+import { findMissingScripts } from "../core/copy/simple.js";
 import { findStaleWorkflows } from "../core/removal-plan.js";
 import { readBaseline } from "../core/baseline.js";
 import { hooksFor, mergeHookResults } from "../core/types.js";
@@ -56,6 +57,9 @@ export function runStatus(payloadRoot, targetRoot = ".") {
       removed: plan.removed.map((f) => f.filename),            // deleted by the user and not restored
     },
     staleFiles: stale,
+    // Installed scripts the workflows need but the repo no longer has; the workflow comparison above cannot see them.
+    missingScripts: findMissingScripts(payloadRoot, targetRoot),
+    droppedPaths: existing.droppedPaths,
   };
 }
 
@@ -90,6 +94,15 @@ export function printStatus(status) {
     for (const f of status.staleFiles) lines.push(`  - ${f}`);
   }
 
+  if (status.missingScripts?.length) {
+    lines.push("", t("cmd.status.missingScripts", { n: status.missingScripts.length, dir: PATHS.scriptsDir }));
+    for (const f of status.missingScripts) lines.push(`  - ${f}`);
+    lines.push(t("cmd.status.missingScriptsFix"));
+  }
+  if (status.droppedPaths?.length) {
+    lines.push("", ...droppedPathLines(status.droppedPaths).map((l) => `⚠️  ${l}`));
+  }
+
   // What an update would do. Installs without a baseline are all zeros, so nothing is printed.
   const b = status.buckets || { autoUpdatable: [], localKept: [], conflicts: [], removed: [] };
   if (b.autoUpdatable.length || b.localKept.length || b.conflicts.length || b.removed.length) {

package/src/core/copy/readme.js

@@ -15,15 +15,66 @@ export const README_STATUS_LABEL = {
   get "skip-no-readme"() { return t("copy.readme.status.skipNoReadme"); },
   get "skip-marker"() { return t("copy.readme.status.skipMarker"); },
   get "skip-version-line"() { return t("copy.readme.status.skipVersionLine"); },
+  get "heading-updated"() { return t("copy.readme.status.headingUpdated"); },
 };
 
+// Bundled default heading text ("Latest Version", ...) without the "## " prefix and version part, per language.
+const defaultHeading = (lang) => t("copy.readme.versionHeading", { version: "0" }, lang).replace(/^##\s*/, "").replace(/\s*:\s*v0$/, "");
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// Text of the history link line in a given language (without the trailing newline).
+const historyLink = (lang) => t("copy.readme.historyLink", {}, lang);
+
+// Rewrites the wizard-made block (marker line, heading line, blank line, history link line) that was written
+// in another language so it matches the current one. Only text that exactly equals another language's bundled
+// default is replaced: a heading or link the user edited is left alone, and so is anything not directly
+// under the marker (code-block examples, a README without the marker).
+// Returns the new content, or null when nothing needs to change.
+function refreshBlockLanguage(content) {
+  const currentHeading = defaultHeading();
+  const currentLink = historyLink();
+  const markerRe = new RegExp("^" + escapeRe(MARKER_LINE.trimEnd()) + "[ \\t]*\\r?\\n", "gm");
+  let out = "";
+  let last = 0;
+  let changed = false;
+  for (let m = markerRe.exec(content); m; m = markerRe.exec(content)) {
+    // An odd number of fence lines before the marker means it sits inside a code block (an example).
+    if ((content.slice(0, m.index).match(/^[ \t]*(```|~~~)/gm) || []).length % 2 === 1) continue;
+    const start = m.index + m[0].length;
+    let rest = content.slice(start);
+    let head = "";
+    // Heading line directly under the marker.
+    for (const lang of SUPPORTED_LANGUAGES) {
+      const heading = defaultHeading(lang);
+      if (heading === currentHeading) continue;
+      const hm = new RegExp("^## " + escapeRe(heading) + " : (?=v[0-9])").exec(rest);
+      if (hm) { head = "## " + currentHeading + " : "; rest = rest.slice(hm[0].length); changed = true; break; }
+    }
+    out += content.slice(last, start) + head;
+    last = start + (content.slice(start).length - rest.length);
+    // History link line: heading line, one blank line, then the link.
+    const lm = /^([^\r\n]*\r?\n\r?\n)([^\r\n]*)/.exec(rest);
+    if (lm) {
+      const linkStart = last + lm[1].length;
+      const isStale = SUPPORTED_LANGUAGES.some((lang) => historyLink(lang) !== currentLink && lm[2] === historyLink(lang));
+      if (isStale) {
+        out += content.slice(last, linkStart) + currentLink;
+        last = linkStart + lm[2].length;
+        changed = true;
+      }
+    }
+  }
+  return changed ? out + content.slice(last) : null;
+}
+
 // Skip when README.md is missing, or when a marker or version line exists. Otherwise append to the end.
-// Returns: 'skip-no-readme' | 'skip-marker' | 'skip-version-line' | 'added'
+// Returns: 'skip-no-readme' | 'heading-updated' | 'skip-marker' | 'skip-version-line' | 'added'
 // Only decides without writing, so the real append and the --dry-run preview share one decision.
 export function planVersionSection(targetRoot = ".") {
   const p = join(targetRoot, "README.md");
   if (!existsSync(p)) return "skip-no-readme";
   const content = readFileSync(p, "utf8");
+  if (refreshBlockLanguage(content) !== null) return "heading-updated";
   if (content.includes(MARKER)) return "skip-marker";
   if (VERSION_LINE_RE.test(content)) return "skip-version-line";
   return "added";
@@ -31,8 +82,13 @@ export function planVersionSection(targetRoot = ".") {
 
 export function addVersionSectionToReadme(version, targetRoot = ".") {
   const status = planVersionSection(targetRoot);
-  if (status !== "added") return status;
   const p = join(targetRoot, "README.md");
+  if (status === "heading-updated") {
+    // Swap only the bundled default wording; version text after the colon stays as the workflow wrote it.
+    writeFileSync(p, refreshBlockLanguage(readFileSync(p, "utf8")));
+    return status;
+  }
+  if (status !== "added") return status;
   const content = readFileSync(p, "utf8");
 
   // The appended body starts with "\n---\n..." to leave a blank line between the existing text and the rule.

package/src/core/copy/simple.js

@@ -24,6 +24,37 @@ export function planScripts(payloadRoot, targetRoot = ".") {
   return out;
 }
 
+// Script -> bundled scripts it imports (`import x` / `from x import ...`), read from the payload so the
+// dependency table cannot drift from the code. Only names in SCRIPT_NAMES count; stdlib imports are ignored.
+function scriptImports(payloadRoot, name) {
+  let src = "";
+  try { src = readFileSync(join(payloadRoot, PAYLOAD.scriptsDir, name), "utf8"); } catch { return []; }
+  const mods = new Set();
+  for (const m of src.matchAll(/^[ \t]*(?:from[ \t]+(\w+)[ \t]+import\b|import[ \t]+([\w, \t]+))/gm)) {
+    if (m[1]) mods.add(m[1]);
+    else for (const x of m[2].split(",")) mods.add(x.trim().split(/\s+/)[0]);
+  }
+  return SCRIPT_NAMES.filter((n) => n !== name && mods.has(n.replace(/\.py$/, "")));
+}
+
+// Bundled scripts the installed workflows call but the repo no longer has (deleted by hand, never copied).
+// Only scripts an installed workflow actually references count: some (truncate_release_notes.py) belong to
+// workflows of one type only. Scripts those import (messages.py, issue_helper.py, ...) are required too,
+// transitively, since the called script fails at import time without them.
+export function findMissingScripts(payloadRoot, targetRoot = ".") {
+  const wfDir = join(targetRoot, PATHS.workflowsDir);
+  let text = "";
+  try {
+    for (const f of readdirSync(wfDir)) if (/\.ya?ml$/.test(f)) text += `${readFileSync(join(wfDir, f), "utf8")}\n`;
+  } catch { return []; }
+  const required = new Set(SCRIPT_NAMES.filter((n) => text.includes(n)));
+  const queue = [...required];
+  while (queue.length) {
+    for (const dep of scriptImports(payloadRoot, queue.pop())) if (!required.has(dep)) { required.add(dep); queue.push(dep); }
+  }
+  return SCRIPT_NAMES.filter((n) => required.has(n) && exists(join(payloadRoot, PAYLOAD.scriptsDir, n)) && !exists(join(targetRoot, PATHS.scriptsDir, n)));
+}
+
 // Scripts are always overwritten with the payload version (+chmod, meaningless but harmless on Windows).
 // User-edited scripts are overwritten too, so per-file results are returned for the caller to log.
 export function copyScripts(payloadRoot, targetRoot = ".") {

package/src/core/copy/workflows.js

@@ -48,7 +48,7 @@ export function readSavedDeployValues(targetRoot = ".") {
 // and status/dry-run never see different file sets. When flutterStore is not an array (null = undecided,
 // non-interactive default) no store filter is applied. It always returns a function even without filters,
 // because processDir cannot take null.
-// Some types (go/python, react/next) keep server deploy workflows directly in the type root, so the deploy style
+// Some types (go, python, react) keep server deploy workflows directly in the type root, so the deploy style
 // filter is always applied. `available` (set of payload file names) lets a type without the chosen style fall back
 // to the single server deploy.
 export function buildTypeRootFilter(type, deployStyle, flutterStore, available = null) {
@@ -64,7 +64,7 @@ export function buildTypeRootFilter(type, deployStyle, flutterStore, available =
 export function typeWorkflowSources(type, payloadRoot, { deployStyle, flutterStore = null, available = null }) {
   const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, type);
   const sources = [];
-  // Some types (go/python, react/next) keep server deploy workflows directly in the type root, so filter the root by deploy style too.
+  // Some types (go, python, react) keep server deploy workflows directly in the type root, so filter the root by deploy style too.
   if (exists(typeDir)) sources.push({ srcDir: typeDir, type, filter: buildTypeRootFilter(type, deployStyle, flutterStore, available) });
   // "No deploy" excludes the whole folder
   if (exists(serverDeployDir) && deployStyle !== NO_DEPLOY_STYLE) {

package/src/core/deploy-style.js

@@ -31,7 +31,7 @@ export const isDeployWorkflow = (filename) => DEPLOY_STYLES.some((s) => filename
 
 const PREVIEW_SUFFIX = "-PR-PREVIEW.yaml";
 
-// All workflows that deploy to a server: CD bodies, single CDs (react, next) and PR preview.
+// All workflows that deploy to a server: CD bodies, the single CD (react) and PR preview.
 // "No deploy" removes all of them identically for every type. Removing only some would leave server Secret requirements behind.
 export const isServerDeployWorkflow = (filename) =>
   isDeployWorkflow(filename) || SINGLE_SERVER_CD_FILES.has(filename) || filename.endsWith(PREVIEW_SUFFIX);

package/src/core/detect.js

@@ -5,7 +5,7 @@ import {
 
 // package.json classification: compares dependency "keys" exactly. A raw substring match would misdetect an
 // export script or exponential-backoff as expo, a web app using react-native-web as react-native, and
-// "next" in keywords as next. Input is the raw package.json string. Evaluation order is the registry's detectOrder.
+// "react" in keywords as react. Input is the raw package.json string. Evaluation order is the registry's detectOrder.
 export function classifyPackageText(raw) {
   let pkg;
   try { pkg = JSON.parse(String(raw || "")); } catch { return PACKAGE_FALLBACK_TYPE; }
@@ -15,7 +15,8 @@ export function classifyPackageText(raw) {
     const d = pkg[field];
     if (d && typeof d === "object") for (const k of Object.keys(d)) deps.add(k);
   }
-  return PACKAGE_DETECTED_TYPES.find((t) => deps.has(t.packageDep))?.id ?? PACKAGE_FALLBACK_TYPE;
+  const hasDep = (t) => [t.packageDep, ...(t.extraPackageDeps || [])].some((k) => deps.has(k));
+  return PACKAGE_DETECTED_TYPES.find(hasDep)?.id ?? PACKAGE_FALLBACK_TYPE;
 }
 
 // Convenience: when given a parsed object, re-serialize it and apply the rule above.

package/src/core/types.js

@@ -11,6 +11,8 @@ import { flutterHooks } from "./flutter-hooks.js";
 //                      "package": detected by a package.json dependency key (packageDep)
 //                      "package-fallback": package.json exists but none of the above matched
 //                      absent: not auto-detected (basic is the result when nothing was detected).
+//   extraPackageDeps   Other dependency keys that also classify a project as this type (e.g. next -> react).
+//   displayName        Human-readable name shown next to the id in interactive choices (optional).
 //   detectOrder        Evaluation order within the same detectBy. The earlier rule wins (an expo app also has a react-native dependency).
 //   versionSources     File keys to read the version from at install (sources in detect.js); read first in this order for the primary type.
 //   buildNumberSource  File key to read the mobile build number from (detectBuildNumberFromFiles in detect.js).
@@ -51,16 +53,11 @@ export const TYPES = [
     hooks: flutterHooks,
   },
   {
-    id: "next",
-    markers: ["package.json"],
-    detectBy: "package", packageDep: "next", detectOrder: 3,
-    versionSources: ["packageJson"],
-    singleServerCd: "PROJECT-NEXT-CICD.yaml",
-  },
-  {
+    // Next.js projects are React projects: same package.json version handling and the same CI/CD workflows.
     id: "react",
+    displayName: "React / Next.js",
     markers: ["package.json"],
-    detectBy: "package", packageDep: "react", detectOrder: 4,
+    detectBy: "package", packageDep: "react", extraPackageDeps: ["next"], detectOrder: 3,
     versionSources: ["packageJson"],
     singleServerCd: "PROJECT-REACT-CICD.yaml",
   },
@@ -109,6 +106,16 @@ export const TYPES = [
 // Type used when nothing was detected
 export const FALLBACK_TYPE = "basic";
 
+// Names that were once separate types and are now accepted as an alias of another one.
+// Every input that can carry a type name (--type, --paths, version.yml) goes through canonicalTypeId(),
+// so the rest of the code only ever sees registry ids and version.yml is rewritten with the canonical name.
+export const TYPE_ALIASES = Object.freeze({ next: "react" });
+
+export const canonicalTypeId = (name) => TYPE_ALIASES[name] ?? name;
+
+// Canonical ids of a type list with duplicates removed (react,next -> react), keeping the first occurrence's position.
+export const canonicalTypeIds = (names) => [...new Set(names.map(canonicalTypeId))];
+
 const BY_ID = new Map(TYPES.map((t) => [t.id, t]));
 
 // Unknown types give undefined; callers decide their own defaults.

package/src/core/version-yml.js

@@ -1,6 +1,7 @@
 import { DEFAULT_DEPLOY_STYLE } from "./deploy-style.js";
 import { escapeYamlDoubleQuoted } from "./wizard-env.js";
-import { hooksFor, mergeHookResults, allHookValues } from "./types.js";
+import { hooksFor, mergeHookResults, allHookValues, canonicalTypeId, canonicalTypeIds } from "./types.js";
+import { normalizePath } from "./paths.js";
 import { DEFAULT_LANGUAGE, isSupportedLanguage, normalizeLanguage } from "../i18n/languages.js";
 // Aliased: `t` is used as a local variable name (type, trimmed line) throughout this file.
 import { t as tr } from "../i18n/index.js";
@@ -88,6 +89,21 @@ export function parseTemplateOptions(content) {
   return out;
 }
 
+// User-facing lines for entries parseExisting() folded away: what is kept, what drops out, and how to keep the other folder.
+// finalPaths (Map<type, folder>) is the folder set the run will actually write; without it the saved winner is assumed.
+// The message follows the real outcome, so an explicit --paths choice is never told the opposite.
+export function droppedPathLines(droppedPaths = [], finalPaths = null) {
+  return droppedPaths.flatMap((d) => {
+    const final = finalPaths?.get(d.type) ?? d.kept;
+    const same = (x) => normalizePath(x) === normalizePath(final);
+    const lost = same(d.kept) ? d.path : same(d.path) ? d.kept : `${d.kept}, ${d.path}`;
+    const lines = [tr("core.versionYml.pathMerged", { keptName: d.keptName, kept: d.kept, name: d.name, path: d.path, type: d.type, final, lost })];
+    // The re-run hint only makes sense when the saved winner is what stays.
+    if (same(d.kept)) lines.push(tr("core.versionYml.pathMergedHint", { type: d.type, path: d.path }));
+    return lines;
+  });
+}
+
 // Extract values from an existing version.yml (line-based, avoids false hits on comment lines).
 export function parseExisting(content) {
   const text = String(content || "");
@@ -107,21 +123,45 @@ export function parseExisting(content) {
   // project_types: ["a","b"]
   const typesRaw = line(/^project_types:\s*(\[[^\]]*\])/);
   let types = [];
-  if (typesRaw) types = [...typesRaw.matchAll(/"([^"]+)"/g)].map((m) => m[1]);
+  // Old names (next) are read as their current type so every later step, including the rewrite, only sees canonical ids.
+  if (typesRaw) types = canonicalTypeIds([...typesRaw.matchAll(/"([^"]+)"/g)].map((m) => m[1]));
   // language: "en" - only supported values count; a hand-edited unknown value is treated as unset
   const langRaw = normalizeLanguage((line(/^language:\s*(.+)/) || "").replace(/\s+#.*$/, "").replace(/["']/g, ""));
   const language = isSupportedLanguage(langRaw) ? langRaw : null;
   // project_paths block: `  type: "path"`
   const paths = new Map();
+  // Entries folded into another entry of the same canonical type with a different folder (react: client + next: web).
+  // A type holds one folder, so these are lost on rewrite; callers surface them instead of dropping them silently.
+  const droppedPaths = [];
+  const pathNames = new Map(); // canonical id -> the name the kept folder was written under
   let inPaths = false;
   for (const l of text.split("\n")) {
     if (/^project_paths:/.test(l)) { inPaths = true; continue; }
     if (inPaths) {
       const m = l.match(/^\s+([a-z-]+):\s*"([^"]*)"/);
-      if (m) paths.set(m[1], m[2]);
+      // The first entry wins when an old name and its current name are both present.
+      if (m) {
+        const id = canonicalTypeId(m[1]);
+        if (!paths.has(id)) { paths.set(id, m[2]); pathNames.set(id, m[1]); }
+        else if (normalizePath(paths.get(id)) !== normalizePath(m[2])) droppedPaths.push({ type: id, keptName: pathNames.get(id), kept: paths.get(id), name: m[1], path: m[2] });
+      }
       else if (/^\S/.test(l)) inPaths = false; // end of indentation -> end of block
     }
   }
+  // A name listed in project_types without a project_paths entry lives at the repo root, so when it shares a
+  // canonical type with a name that has a folder, the root is the folder that drops out.
+  if (typesRaw) {
+    const names = [...new Set([...typesRaw.matchAll(/"([^"]+)"/g)].map((m) => m[1]))];
+    const written = new Set(text.split("\n").map((l) => l.match(/^\s+([a-z-]+):\s*"/)?.[1]).filter(Boolean));
+    for (const id of new Set(names.map(canonicalTypeId))) {
+      const group = names.filter((n) => canonicalTypeId(n) === id);
+      if (group.length < 2 || !paths.has(id)) continue;
+      for (const n of group) {
+        if (written.has(n) || normalizePath(paths.get(id)) === ".") continue;
+        droppedPaths.push({ type: id, keptName: pathNames.get(id), kept: paths.get(id), name: n, path: "." });
+      }
+    }
+  }
   // version inside the template: block
   let templateVersion = "";
   let inTemplate = false;
@@ -138,7 +178,7 @@ export function parseExisting(content) {
   // metadata.template.branches - main/develop/mode (to skip re-asking in update mode)
   const branches = parseTemplateBranches(text);
   return {
-    version, versionCode, types, language, paths, templateVersion, options, branches,
+    version, versionCode, types, language, paths, droppedPaths, templateVersion, options, branches,
     deploy: parseDeployBlock(text), extraTopLevel: parseExtraTopLevel(text),
   };
 }
@@ -157,9 +197,15 @@ export function parseDeployBlock(content) {
     if (!inDeploy) continue;
     if (/^\S/.test(l)) { inDeploy = false; continue; } // next top-level key -> end of block
     const t = l.match(/^ {2}([a-z][a-z-]*):\s*(?:#.*)?$/);
-    if (t) { current = new Map(); out.set(t[1], current); continue; }
+    if (t) {
+      // An old type name shares the block of its current name; keys already present there win.
+      const id = canonicalTypeId(t[1]);
+      current = out.get(id) ?? new Map();
+      out.set(id, current);
+      continue;
+    }
     const kv = l.match(/^ {4}([A-Za-z_][A-Za-z0-9_]*):\s*"((?:[^"\\]|\\.)*)"/);
-    if (kv && current) current.set(kv[1], kv[2].replace(/\\(["\\])/g, "$1"));
+    if (kv && current && !current.has(kv[1])) current.set(kv[1], kv[2].replace(/\\(["\\])/g, "$1"));
   }
   return out;
 }

package/src/i18n/catalog/en/cli.js

@@ -20,6 +20,7 @@ export default {
   "cli.args.unknownOption": "Unknown option: {option}",
   "cli.args.modeUnsupported": "Unsupported mode: '{mode}'\nSupported modes: interactive full uninstall status doctor",
   "cli.args.pathsTypeUnsupported": "Unsupported type in --paths: '{type}'",
+  "cli.args.pathsDuplicateType": "--paths lists '{type}' twice with different folders (next is the old name of react); keep one entry",
   "cli.args.pathsRelativeOnly": "--paths accepts only paths relative to the repo: '{pair}'",
   "cli.index.purgePrompt": "To run purge, type this repo name exactly: {repoName}\n> ",
   "cli.index.dryRunNeedsMode": "Use --dry-run together with --mode <full|uninstall> (it is not supported in interactive mode).",