project-auto-wizard 0.15.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);
     }

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 = {

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/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).",

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

@@ -12,6 +12,8 @@ export default {
   "cmd.status.modified": "Workflow files modified by the user ({n}):",
   "cmd.status.unmodified": "All workflow files match their install-time defaults (no modifications).",
   "cmd.status.stale": "Old workflows not in the current version ({n}; cleaned up on the next update):",
+  "cmd.status.missingScripts": "Warning: {n} installed script(s) missing from {dir}/ (workflows call them and will fail at run time):",
+  "cmd.status.missingScriptsFix": "  Restore them with: npx project-auto-wizard --mode full --force",
   "cmd.status.bucketsTitle": "If you update now:",
   "cmd.status.bucketAuto": "  Upstream changed - auto-applicable    {n}",
   "cmd.status.bucketLocalKept": "  Edited by me - upstream unchanged     {n}   (kept)",
@@ -24,6 +26,12 @@ export default {
   "cmd.doctor.install.purpose": "Whether the wizard is installed in this folder",
   "cmd.doctor.install.value": "version.yml found",
   "cmd.doctor.install.note": "Not installed in this folder yet; you can install now.",
+  "cmd.doctor.scripts.name": "Installed scripts",
+  "cmd.doctor.scripts.label": "Installed scripts",
+  "cmd.doctor.scripts.purpose": "Scripts the installed workflows call",
+  "cmd.doctor.scripts.missing": "Missing from .github/scripts/: {files}",
+  "cmd.doctor.scripts.impact": "Workflow steps that call them stop with a clear error (messages.py is missing) instead of carrying on.",
+  "cmd.doctor.scripts.action": "Restore them with: npx project-auto-wizard --mode full --force",
   "cmd.doctor.gh.purpose": "For reading repo settings",
   "cmd.doctor.gh.notFound": "The gh CLI was not found.",
   "cmd.doctor.gh.notFoundImpact": "Repo permissions and secrets cannot be read, so all remote checks below are skipped.",

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

@@ -1,6 +1,9 @@
 // English messages: core area (part 2).
 export default {
   "core.breakingCheck.confirm": "Have you reviewed the breaking changes above and want to continue?",
+  "core.versionYml.pathMergedTitle": "One folder per type",
+  "core.versionYml.pathMerged": "version.yml lists '{keptName}' (folder {kept}) and '{name}' (folder {path}) separately, but they are now the same type and only one folder per type is managed. Keeping {type}={final}; {lost} drops out of CI and version sync.",
+  "core.versionYml.pathMergedHint": "To manage {path} instead, rerun with --paths {type}={path}; to keep both, add a hand-written CI workflow for the dropped folder.",
   "core.breakingCheck.nonInteractive": "⚠️  There are CRITICAL breaking changes - continuing because this is a non-interactive run. Be sure to review the notes above.",
   "core.logger.error.nameExhausted": "All log file names are in use: {base}",
   "core.logger.warn.startFailed": "Could not start the run log: {message}",

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

@@ -20,6 +20,7 @@ export default {
   "cli.args.unknownOption": "알 수 없는 옵션: {option}",
   "cli.args.modeUnsupported": "지원하지 않는 모드: '{mode}'\n지원 모드: interactive full uninstall status doctor",
   "cli.args.pathsTypeUnsupported": "--paths에 지원하지 않는 타입: '{type}'",
+  "cli.args.pathsDuplicateType": "--paths에 '{type}'이 서로 다른 폴더로 두 번 지정됨 (next는 react의 이전 이름입니다): 한 항목만 남기세요",
   "cli.args.pathsRelativeOnly": "--paths는 레포 안의 상대경로만 지정할 수 있습니다: '{pair}'",
   "cli.index.purgePrompt": "purge를 실행하려면 정확히 이 레포명을 입력하세요: {repoName}\n> ",
   "cli.index.dryRunNeedsMode": "--dry-run은 --mode <full|uninstall>와 함께 사용하세요 (대화형 모드에서는 지원하지 않습니다).",

package/src/i18n/catalog/ko/commands.js

@@ -12,6 +12,8 @@ export default {
   "cmd.status.modified": "사용자가 수정한 워크플로우 파일 ({n}개):",
   "cmd.status.unmodified": "모든 워크플로우 파일이 설치 시점 기본값과 동일합니다 (수정 없음).",
   "cmd.status.stale": "현재 버전에 없는 이전 워크플로우 ({n}개 — 다음 업데이트에서 정리됨):",
+  "cmd.status.missingScripts": "경고: 설치된 스크립트 {n}개가 {dir}/ 에 없습니다 (워크플로우가 호출하므로 실행 시 실패합니다):",
+  "cmd.status.missingScriptsFix": "  복구: npx project-auto-wizard --mode full --force",
   "cmd.status.bucketsTitle": "지금 업데이트하면:",
   "cmd.status.bucketAuto": "  업스트림 변경 — 자동 적용 가능   {n}",
   "cmd.status.bucketLocalKept": "  내가 수정 · 업스트림 그대로      {n}   (유지)",
@@ -24,6 +26,12 @@ export default {
   "cmd.doctor.install.purpose": "이 폴더의 마법사 설치 여부",
   "cmd.doctor.install.value": "version.yml 있음",
   "cmd.doctor.install.note": "이 폴더엔 아직 설치되지 않았습니다 — 지금 설치하면 됩니다.",
+  "cmd.doctor.scripts.name": "설치된 스크립트",
+  "cmd.doctor.scripts.label": "설치된 스크립트",
+  "cmd.doctor.scripts.purpose": "설치된 워크플로우가 호출하는 스크립트",
+  "cmd.doctor.scripts.missing": ".github/scripts/ 에 없음: {files}",
+  "cmd.doctor.scripts.impact": "이 스크립트를 호출하는 스텝은 누락을 알리는 오류(messages.py is missing)로 명확히 실패합니다.",
+  "cmd.doctor.scripts.action": "복구: npx project-auto-wizard --mode full --force",
   "cmd.doctor.gh.purpose": "레포 설정 조회용",
   "cmd.doctor.gh.notFound": "gh CLI를 찾을 수 없습니다.",
   "cmd.doctor.gh.notFoundImpact": "레포 권한·secret 설정을 조회할 수 없어 아래 원격 점검을 모두 건너뜁니다.",

package/src/i18n/catalog/ko/core2.js

@@ -1,6 +1,9 @@
 // 한국어 메시지: core 영역 (2부).
 export default {
   "core.breakingCheck.confirm": "위 호환성 변경을 확인했고 계속 진행할까요?",
+  "core.versionYml.pathMergedTitle": "타입당 폴더 하나",
+  "core.versionYml.pathMerged": "version.yml 에 '{keptName}'(폴더 {kept})과 '{name}'(폴더 {path})이 따로 적혀 있지만 이제 같은 타입이라 타입당 폴더 하나만 관리합니다. {type}={final} 를 유지하고, {lost} 는 CI·버전 동기화에서 빠집니다.",
+  "core.versionYml.pathMergedHint": "{path} 를 대신 관리하려면 --paths {type}={path} 로 다시 실행하세요. 둘 다 유지하려면 빠진 폴더용 CI 워크플로우를 직접 추가하세요.",
   "core.breakingCheck.nonInteractive": "⚠️  CRITICAL 호환성 변경이 있습니다 — 비대화형 실행이라 계속 진행합니다. 위 내용을 꼭 확인하세요.",
   "core.logger.error.nameExhausted": "로그 파일 이름이 모두 사용 중입니다: {base}",
   "core.logger.warn.startFailed": "실행 로그를 시작하지 못했습니다: {message}",

package/src/index.js

@@ -14,7 +14,7 @@ import { hooksFor, mergeHookResults } from "./core/types.js";
 import { PATHS } from "./core/paths.js";
 import { resolvePayloadRoot, assertPayload, readTemplateVersion } from "./core/assets.js";
 import { detectTypes, 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 { resolveReleaseOptions } from "./core/release-options.js";
 import { runBreakingCheck } from "./core/breaking-check.js";
 import { resolveProjectPaths } from "./core/paths-resolve.js";
@@ -316,6 +316,9 @@ async function runInner(argv, {
     throw e;
   }
 
+  // Warn against the final folders (an explicit --paths may keep the other one). The dry-run preview prints its own notice.
+  if (!opts.dryRun) for (const line of droppedPathLines(existing?.droppedPaths, paths)) console.error(`⚠️  ${line}`);
+
   // version: existing version.yml first (SSoT; prevents overwriting on re-run) -> CLI value -> file detection.
   // Non-interactive, so the fallback notice uses the CLI wording (--project-version) as is.
   // Detect after paths are confirmed so a monorepo subfolder's version and build number are read.

package/src/ui/env-plan.js

@@ -59,7 +59,7 @@ export function collectAsks(payloadRoot, types = [], opts = {}) {
     const [typeDir, serverDeployDir] = typeWorkflowDirs(payloadRoot, type);
     if (!exists(typeDir)) continue;
     // Same folder layout as the copy engine: type root + server-deploy (only when deploy is not "none").
-    // Types such as go/python and react/next keep server deploy workflows directly in the type root; they go
+    // Types such as go, python and react keep server deploy workflows directly in the type root; they go
     // through the same deploy-style filter - with "no deploy", CD/PR-preview ask keys (DEPLOY_PORT, SSH_AUTH_METHOD, ...) are not asked.
     // Flutter also filters out deselected store workflows (PLAYSTORE, TESTFLIGHT) so the question scope equals the install scope.
     units.push([type, typeDir, buildTypeRootFilter(type, deployStyle, flutterStore, available)]);