project-auto-wizard 0.13.3 → 0.15.0

package/src/core/deploy-style.js

@@ -1,54 +1,56 @@
-// 배포 방식 — 서버 배포 CD 워크플로우는 서로 대체재다.
-// Nginx 무중단과 Traefik 무중단을 동시에 쓰는 경우는 없으므로 하나만 설치한다.
-// 고른 것은 push 트리거까지 켜서 설치한다 — 설치했는데 안 도는 상태를 만들지 않는다.
+// Deploy style: the server-deploy CD workflows are alternatives to each other.
+// Nginx zero-downtime and Traefik zero-downtime are never used together, so only one is installed.
+// The chosen one is installed with its push trigger enabled, so nothing is installed that then never runs.
 import { join } from "node:path";
 import { existsSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
 import { sha256 } from "./baseline.js";
 import { PAYLOAD, typeWorkflowDirs } from "./paths.js";
 import { SINGLE_SERVER_CD_FILES } from "./types.js";
+import { t } from "../i18n/index.js";
 
-// 파일명 접미사로 식별한다 — 타입 접두사(PROJECT-SPRING- 등)는 타입마다 다르기 때문.
+// Identified by file name suffix, because the type prefix (PROJECT-SPRING- etc.) differs per type.
+// label is a getter so the text follows the language resolved after import.
 export const DEPLOY_STYLES = [
-  { value: "simple", suffix: "-SIMPLE-CICD.yaml", label: "단일 서버 배포 — 컨테이너를 내렸다 올린다 (가장 단순, 짧은 다운타임)" },
-  { value: "nginx", suffix: "-NONSTOP-NGINX-CICD.yaml", label: "무중단 배포 (Nginx) — nginx config의 proxy_pass 포트를 Blue/Green으로 토글" },
-  { value: "traefik", suffix: "-NONSTOP-TRAEFIK-CICD.yaml", label: "무중단 배포 (Traefik) — Traefik 라우팅으로 Blue/Green 전환" },
+  { value: "simple", suffix: "-SIMPLE-CICD.yaml", get label() { return t("core.deploy.label.simple"); } },
+  { value: "nginx", suffix: "-NONSTOP-NGINX-CICD.yaml", get label() { return t("core.deploy.label.nginx"); } },
+  { value: "traefik", suffix: "-NONSTOP-TRAEFIK-CICD.yaml", get label() { return t("core.deploy.label.traefik"); } },
 ];
 
 export const DEFAULT_DEPLOY_STYLE = "simple";
 
-// 서버 배포 자체를 하지 않는 프로젝트(프론트엔드 전용, 라이브러리 등)를 위한 값.
-// DEPLOY_STYLES에는 넣지 않는다 — isDeployWorkflow/suffixOf가 이 배열을 순회하는데, 빈 접미사를
-// 돌려주면 endsWith("")가 항상 참이라 모든 파일이 CD로 오판되어 cleanupOtherDeployWorkflows가
-// 설치된 워크플로우 전체를 지우는 회귀가 생긴다.
+// Value for projects that do no server deploy at all (frontend-only, libraries, etc.).
+// Not put into DEPLOY_STYLES: isDeployWorkflow/suffixOf iterate that array, and an empty suffix would make
+// endsWith("") always true, so every file would be misjudged as CD and cleanupOtherDeployWorkflows would
+// delete all installed workflows (a regression).
 export const NO_DEPLOY_STYLE = "none";
 
 export const isDeployStyle = (v) => v === NO_DEPLOY_STYLE || DEPLOY_STYLES.some((s) => s.value === v);
 
-// 이 파일이 CD 본체인가 (= 택1 대상인가). PR 프리뷰는 배포 방식과 직교하는 축이라 제외한다.
+// Whether this file is a CD body (= subject of the pick-one choice). PR preview is orthogonal to the deploy style, so it is excluded.
 export const isDeployWorkflow = (filename) => DEPLOY_STYLES.some((s) => filename.endsWith(s.suffix));
 
 const PREVIEW_SUFFIX = "-PR-PREVIEW.yaml";
 
-// 서버에 배포하는 워크플로우 전부 — CD 본체, 단일 CD(react·next), PR 프리뷰.
-// "배포 안 함"은 이 전부를 모든 타입에서 똑같이 뺀다. 일부만 빼면 서버 Secret 요구가 남는다.
+// All workflows that deploy to a server: CD bodies, single CDs (react, next) 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);
 
-// 선택한 타입 중 서버 배포 워크플로우를 가진 타입이 있는가 — payload 파일로 판정한다.
-// 없으면(node·flutter 등) 배포 방식은 설치 결과에 아무 영향이 없으므로 묻지도 기록하지도 않는다.
+// Whether any selected type has server deploy workflows, judged from the payload files.
+// If none (node, flutter, etc.) the deploy style has no effect on the install result, so it is neither asked nor recorded.
 export function hasServerDeployWorkflows(payloadRoot, types = []) {
   return types.some((type) => typeWorkflowDirs(payloadRoot, type)
     .some((dir) => existsSync(dir) && readdirSync(dir).some(isServerDeployWorkflow)));
 }
 
-// 선택한 타입 중 무중단(nginx·traefik) 워크플로우가 있는 타입이 있는가 — 없으면 무중단 선택지를 보이지 않는다.
+// Whether any selected type has zero-downtime (nginx, traefik) workflows; if none, the zero-downtime choices are not shown.
 export function hasNonstopWorkflows(payloadRoot, types = []) {
   const nonstop = DEPLOY_STYLES.filter((s) => s.value !== DEFAULT_DEPLOY_STYLE).map((s) => s.suffix);
   return types.some((type) => typeWorkflowDirs(payloadRoot, type)
     .some((dir) => existsSync(dir) && readdirSync(dir).some((f) => nonstop.some((sfx) => f.endsWith(sfx)))));
 }
 
-// payload/workflows/** 의 워크플로우 파일명 전체. 파일명은 PROJECT-{TYPE}- 접두사로 타입 간 유일하다.
+// All workflow file names under payload/workflows/**. File names are unique across types thanks to the PROJECT-{TYPE}- prefix.
 export function payloadWorkflowNames(payloadRoot) {
   const names = new Set();
   const root = join(payloadRoot, PAYLOAD.workflowsDir);
@@ -59,24 +61,24 @@ export function payloadWorkflowNames(payloadRoot) {
   return names;
 }
 
-// 모르는 값은 기본값으로 수렴시킨다. 빈 접미사를 돌려주면 endsWith("")가 항상 참이라
-// "전부 통과"가 되어, 잘못된 값이 조용히 CD 전부 설치로 새어나간다.
+// Unknown values converge to the default. Returning an empty suffix would make endsWith("") always true,
+// i.e. "everything passes", and an invalid value would silently leak into installing every CD.
 const suffixOf = (style) =>
   (DEPLOY_STYLES.find((s) => s.value === style) ?? DEPLOY_STYLES.find((s) => s.value === DEFAULT_DEPLOY_STYLE)).suffix;
 const SIMPLE_SUFFIX = suffixOf(DEFAULT_DEPLOY_STYLE);
 
-// 고른 방식의 CD가 없는 타입의 단일 서버 배포 CD인가 (예: nginx를 골랐는데 python·go에는 NONSTOP이 없다).
-// 그런 타입은 단일 서버 배포로 대신 설치한다 — 설치 직후 지우거나 .bak으로 옮기면 배포가 사라진다.
+// Whether this is the single-server deploy CD of a type that lacks the chosen style's CD (e.g. nginx was chosen but python and go have no NONSTOP).
+// Such types get the single-server deploy instead: deleting it or moving it to .bak right after install would leave no deploy at all.
 function isFallbackSimple(filename, style, available) {
   if (!available || !filename.endsWith(SIMPLE_SUFFIX)) return false;
   const prefix = filename.slice(0, -SIMPLE_SUFFIX.length);
   return !available.has(prefix + suffixOf(style));
 }
 
-// 파일 필터 — 고른 방식의 CD만 통과. CD가 아닌 파일(PR 프리뷰·common 등)은 항상 통과.
-// "none"은 서버 배포 워크플로우(CD·단일 CD·PR 프리뷰)를 하나도 설치하지 않는다.
-// available: payload 워크플로우 파일명 집합(payloadWorkflowNames). 주면 고른 방식이 없는 타입은
-// 단일 서버 배포로 대체한다. 없으면 접미사만으로 가른다.
+// File filter: only the chosen style's CD passes. Non-CD files (PR preview, common, etc.) always pass.
+// "none" installs no server-deploy workflow at all (CD, single CD, PR preview).
+// available: set of payload workflow file names (payloadWorkflowNames). When given, types without the chosen
+// style fall back to the single-server deploy. Without it, only the suffix decides.
 export function deployFilter(style, available = null) {
   if (style === NO_DEPLOY_STYLE) return (filename) => !isServerDeployWorkflow(filename);
   const suffix = suffixOf(style);
@@ -84,7 +86,7 @@ export function deployFilter(style, available = null) {
     || isFallbackSimple(filename, style, available);
 }
 
-// 고른 방식(nginx·traefik)의 워크플로우가 없어 단일 서버 배포로 대신 설치하는 타입 목록 — 안내용.
+// Types that get the single-server deploy instead because they lack workflows for the chosen style (nginx, traefik); for notices.
 export function fallbackStyleTypes(payloadRoot, types = [], style) {
   if (!style || style === NO_DEPLOY_STYLE || suffixOf(style) === SIMPLE_SUFFIX) return [];
   return types.filter((type) => {
@@ -94,9 +96,10 @@ export function fallbackStyleTypes(payloadRoot, types = [], style) {
   });
 }
 
-// 실제로 설치되는 배포 방식 — 고른 무중단 방식의 워크플로우가 선택한 타입 어디에도 없으면 전부 단일 서버
-// 배포로 대신 설치되므로 simple이다. 고른 값을 그대로 기록하면 version.yml·status가 설치 상태와 어긋나고,
-// 다음 실행도 그 값을 기본값으로 이어받는다. 한 타입이라도 그 방식이 있으면 고른 값을 유지한다.
+// The deploy style that is actually installed: if no selected type has workflows for the chosen zero-downtime
+// style, all of them get the single-server deploy, so the result is simple. Recording the chosen value as is would
+// make version.yml and status disagree with what was installed, and the next run would inherit it as the default.
+// If even one type has that style, the chosen value is kept.
 export function effectiveDeployStyle(payloadRoot, types = [], style) {
   if (!style || style === NO_DEPLOY_STYLE || suffixOf(style) === SIMPLE_SUFFIX) return style;
   const installed = types.some((type) => typeWorkflowDirs(payloadRoot, type)
@@ -104,12 +107,12 @@ export function effectiveDeployStyle(payloadRoot, types = [], style) {
   return installed ? style : DEFAULT_DEPLOY_STYLE;
 }
 
-// 무중단 템플릿은 push 트리거가 주석 처리된 채 들어 있다(기본 배포가 단일 서버라서).
-// 사용자가 그 방식을 고른 이상 트리거는 켜져 있어야 한다 — 안 그러면 설치해도 아무 일이
-// 일어나지 않고 사용자가 YAML을 직접 고쳐야 한다.
+// Zero-downtime templates ship with the push trigger commented out (because the default deploy is the single server).
+// Once the user has chosen that style the trigger must be on: otherwise nothing happens after install and the
+// user has to edit the YAML by hand.
 //
-// 첫 `on:` 블록 안에서 `# ` 두 글자만 떼므로 안쪽 들여쓰기 계층이 그대로 보존된다.
-// 설명문 주석은 벗겨낸 내용이 push/branches/- 로 시작하지 않아 건드리지 않는다.
+// Inside the first `on:` block only the two characters `# ` are removed, so the inner indentation hierarchy is preserved.
+// Explanatory comments are left alone because their stripped content does not start with push/branches/-.
 const TRIGGER_CONTENT = /^\s*(push:|branches:|- )/;
 
 export function activateDeployTrigger(content) {
@@ -121,7 +124,7 @@ export function activateDeployTrigger(content) {
     const line = lines[i];
     if (/^on:\s*$/.test(line)) { inOn = true; continue; }
     if (!inOn) continue;
-    if (/^\S/.test(line)) break; // 최상위 키를 다시 만나면 on 블록 종료
+    if (/^\S/.test(line)) break; // a top-level key ends the on block
     const m = line.match(/^(\s*)# ?(.*)$/);
     if (!m || !TRIGGER_CONTENT.test(m[2])) continue;
     lines[i] = `${m[1]}${m[2]}`;
@@ -130,20 +133,20 @@ export function activateDeployTrigger(content) {
   return changed ? lines.join(eol) : content;
 }
 
-// 방식을 바꿔 재설치했을 때 이전 CD를 정리한다.
+// Cleans up the previous CD when reinstalling with a different style.
 //
-// 남겨두면 이전 방식의 push 트리거가 살아 있어 배포가 두 번 돈다. 그렇다고 사용자에게
-// "직접 지우세요"라고 떠넘기면 설치가 끝나도 레포가 정상이 아닌 상태로 남는다. 마법사가
-// 깐 파일은 마법사가 정리한다.
+// Leaving it would keep the old style's push trigger alive and deploy twice. Telling the user to "delete it
+// yourself" would leave the repo in a broken state even after install finishes. Files the wizard installed are
+// cleaned up by the wizard.
 //
-//   손대지 않은 것(baseline의 installed 해시와 동일) → 삭제. 물어볼 이유가 없다.
-//   손댄 것                                          → .bak으로 옮긴다. 내용은 지키고 트리거만 죽인다.
+//   untouched (same as the baseline installed hash) -> deleted. No reason to ask.
+//   modified                                        -> moved to .bak. Content is kept and only the trigger is killed.
 //
-// opts.available  — payload 워크플로우 파일명 집합. 주면 그 안의 파일(마법사가 까는 파일)만 정리하고,
-//                   고른 방식이 없는 타입의 단일 서버 배포는 남긴다.
-// opts.justWritten — 이번 실행에서 마법사가 방금 쓴 파일. 첫 설치처럼 baseline이 없어도 수정본으로 오인하지 않는다.
-// opts.dryRun      — 판정만 하고 파일은 건드리지 않는다. --dry-run 미리보기가 실제 실행과 같은 판정을 쓰게 한다.
-// 반환: { removed:[], backedUp:[] } — 완료 화면·설치 기록에 그대로 보고한다.
+// opts.available   - set of payload workflow file names. When given, only files in it (files the wizard installs)
+//                    are cleaned up, and the single-server deploy of types lacking the chosen style is kept.
+// opts.justWritten - files the wizard just wrote in this run. Not mistaken for modified files even without a baseline, as on a first install.
+// opts.dryRun      - only decide, do not touch files. Makes the --dry-run preview use the same decision as a real run.
+// Returns { removed:[], backedUp:[] }, reported as is on the completion screen and in the install record.
 export function cleanupOtherDeployWorkflows(workflowsDir, installedFilenames, style, baseline, { available = null, justWritten = [], dryRun = false } = {}) {
   const keep = deployFilter(style, available);
   const written = new Set(justWritten);
@@ -152,7 +155,7 @@ export function cleanupOtherDeployWorkflows(workflowsDir, installedFilenames, st
 
   for (const filename of installedFilenames) {
     if (!isServerDeployWorkflow(filename) || keep(filename)) continue;
-    if (available && !available.has(filename)) continue; // 사용자가 만든 비슷한 이름의 워크플로우는 건드리지 않는다
+    if (available && !available.has(filename)) continue; // never touch a similarly named workflow the user created
     const p = join(workflowsDir, filename);
     if (!existsSync(p)) continue;
 

package/src/core/detect-fs.js

@@ -1,11 +1,12 @@
-// 실 파일시스템 프로젝트 감지.
-// detect.js 순수 함수를 fs/git으로 구동한다.
+// Project detection on the real filesystem.
+// Drives the pure functions of detect.js with fs/git.
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { execFileSync } from "node:child_process";
 import { detectTypesFromMarkers, detectVersionFromFiles, detectBuildNumberFromFiles, detectJdkFromFiles, resolveMarkers } from "./detect.js";
 import { parseExisting } from "./version-yml.js";
 import { isValidBranchName } from "./branches.js";
+import { t as tr } from "../i18n/index.js";
 
 const hasFile = (root) => (rel) => existsSync(join(root, rel));
 const readFile = (root) => (rel) => {
@@ -18,19 +19,19 @@ function gitOut(root, args) {
   } catch { return ""; }
 }
 
-// 타입 감지 — version.yml의 project_types 최우선(source of truth), 없으면 마커 스캔.
-// paths: --paths로 받은 Map<type,path>. 모노레포는 루트에 마커가 없으므로 사용자가 적은 타입을 쓴다.
-// warn: 루트에 마커가 없어 basic으로 떨어질 때 하위 폴더에서 찾은 프로젝트를 알린다.
+// Type detection: project_types in version.yml wins (source of truth), otherwise a marker scan.
+// paths: Map<type,path> from --paths. A monorepo has no markers at the root, so the types the user listed are used.
+// warn: when no root marker exists and detection falls back to basic, reports projects found in subfolders.
 export function detectTypes(root, { paths = new Map(), warn } = {}) {
   const vy = join(root, "version.yml");
   if (existsSync(vy)) {
     const { types } = parseExisting(readFileSync(vy, "utf8"));
-    if (types.length) return types; // basic 포함, 명시돼 있으면 그대로
+    if (types.length) return types; // includes basic; used as-is when explicit
   }
   const fromRoot = detectTypesFromMarkers({ has: hasFile(root), read: readFile(root) });
   if (paths.size) {
-    // --paths 순서가 주 타입을 정한다. 루트 package.json의 node는 다른 타입이 있으면 빼는
-    // 마커 스캔 규칙과 맞춘다.
+    // The --paths order decides the primary type. Matches the marker-scan rule that drops the root
+    // package.json's node when another type exists.
     const merged = [...new Set([...paths.keys(), ...fromRoot])].filter((t) => t !== "basic");
     const types = merged.length > 1 ? merged.filter((t) => t !== "node" || paths.has("node")) : merged;
     return types.length ? types : ["basic"];
@@ -42,15 +43,14 @@ export function detectTypes(root, { paths = new Map(), warn } = {}) {
       for (const { dir, types } of found) for (const t of types) if (!firstDir.has(t)) firstDir.set(t, dir);
       const list = found.map(({ dir, types }) => `${dir}(${types.join(", ")})`).join(", ");
       const hint = [...firstDir].map(([t, d]) => `${t}=${d}`).join(",");
-      warn(`⚠️  루트에서 프로젝트 파일을 찾지 못해 basic으로 설치합니다. 하위 폴더에서 발견: ${list}\n` +
-        `   모노레포라면 --paths "${hint}"로 다시 실행하세요.`);
+      warn(tr("core.detectFs.monorepoWarn", { list, hint }));
     }
   }
   return fromRoot;
 }
 
-// 루트 아래 2단계까지 프로젝트 마커가 있는 폴더를 찾는다 (모노레포 안내용).
-// 빌드 산출물·의존성·네이티브 폴더는 오탐만 늘리므로 들어가지 않고, 찾은 폴더의 하위도 보지 않는다.
+// Finds folders with project markers up to 2 levels below the root (for monorepo hints).
+// Build output, dependency and native folders only add false positives, so they are skipped, and the children of a found folder are not scanned.
 const SUBDIR_PRUNE = new Set(["node_modules", "build", "dist", "android", "ios", "venv", "__pycache__"]);
 function findSubdirProjects(root, maxDepth = 2) {
   const found = [];
@@ -70,10 +70,10 @@ function findSubdirProjects(root, maxDepth = 2) {
   return found.sort((a, b) => a.dir.localeCompare(b.dir));
 }
 
-// 버전 감지 — 타입별 버전 파일을 순서대로 읽는다.
-// hint: 폴백 경고에 붙일 해결 방법 안내 (대화형/CLI가 다르다).
-// 모노레포(--paths)는 버전 파일이 타입 폴더 안에 있다 — 루트만 보면 0.0.1/1로 초기화된다.
-// 주 타입 폴더 → 나머지 타입 폴더 → 루트 순으로 찾는다.
+// Version detection: reads each type's version files in order.
+// hint: fix guidance appended to the fallback warning (differs between interactive mode and the CLI).
+// In a monorepo (--paths) the version files live inside the type folders; looking only at the root would reset to 0.0.1/1.
+// Search order: primary type folder, then the other type folders, then the root.
 function projectBases(types = [], paths = null) {
   const bases = [];
   for (const t of types) {
@@ -83,7 +83,7 @@ function projectBases(types = [], paths = null) {
   return bases.length ? [...bases, "."] : ["."];
 }
 
-// 첫 번째로 결과가 있는 기준 폴더의 값을 쓴다 — read와 list가 같은 폴더 우선순위를 따른다.
+// Uses the value from the first base folder that has a result, so read and list follow the same folder priority.
 function firstFromBases(bases, fn) {
   return (rel) => {
     for (const b of bases) {
@@ -98,7 +98,7 @@ function readFromProject(root, types = [], paths = null) {
   return firstFromBases(projectBases(types, paths), readFile(root));
 }
 
-// 하위 폴더 이름 목록 (React Native의 ios/<앱>/Info.plist 탐색용). 폴더가 없으면 null.
+// Subfolder names (for React Native's ios/<app>/Info.plist lookup). null when the folder does not exist.
 function listFromProject(root, types = [], paths = null) {
   const listDirs = (rel) => {
     try {
@@ -116,45 +116,45 @@ export function detectVersion(root, { warn = (m) => console.error(m), hint, type
   return detectVersionFromFiles({ read, readJson, list, gitTag, warn, hint, types });
 }
 
-// 타입별 실제 마커 파일 — 감지 로그·설치 로그가 같은 근거 파일을 인용하도록.
+// Real marker file per type, so the detection log and install log cite the same evidence file.
 export function detectMarkers(root, types = []) {
   return resolveMarkers(types, hasFile(root));
 }
 
-// 빌드 JDK 감지 — 배포 워크플로우 JAVA_VERSION 기본값에 실측값을 쓰기 위해.
-// base: 모노레포에서 spring 프로젝트 루트 (레포 루트 기준 상대경로).
+// Build JDK detection, so the measured value can be used as the deploy workflow's JAVA_VERSION default.
+// base: the spring project root in a monorepo (relative to the repo root).
 export function detectJdk(root, base = ".") {
   const rel = base && base !== "." ? (r) => `${base}/${r}` : (r) => r;
   const read = readFile(root);
   return detectJdkFromFiles({ read: (r) => read(rel(r)) });
 }
 
-// 빌드 번호 감지 — 신규 통합 시 pubspec.yaml/build.gradle/app.json에서 실제 빌드 번호를 읽는다.
+// Build number detection: on a fresh integration, reads the real build number from pubspec.yaml/build.gradle/app.json.
 export function detectBuildNumber(root, { types = [], paths = null, warn = (m) => console.error(m) } = {}) {
   const read = readFromProject(root, types, paths);
   const readJson = (rel) => { const c = read(rel); try { return c ? JSON.parse(c) : null; } catch { return null; } };
   return detectBuildNumberFromFiles({ types, read, readJson, warn });
 }
 
-// 기본 브랜치 감지 — symbolic-ref → remote show → main.
-// 빈 원격(remote add만 하고 push 전)은 remote show가 "HEAD branch: (unknown)"을 돌려준다. 이 값이
-// 워크플로우 트리거에 기록되면 릴리스 자동화가 조용히 멈추므로, 유효한 브랜치 이름만 인정하고
-// 아니면 로컬 현재 브랜치(첫 push 대상) → main 순으로 폴백하며 경고한다.
-// hint: 경고에 붙일 해결 방법 안내 (대화형/CLI가 다르다).
+// Default branch detection: symbolic-ref, then remote show, then main.
+// For an empty remote (remote add without a push yet) remote show returns "HEAD branch: (unknown)". If that value
+// were written into the workflow trigger, release automation would silently stop, so only valid branch names are
+// accepted; otherwise it falls back to the current local branch (first push target), then main, and warns.
+// hint: fix guidance appended to the warning (differs between interactive mode and the CLI).
 export function detectDefaultBranch(root, { warn = null, hint = "" } = {}) {
   const b = gitOut(root, ["symbolic-ref", "refs/remotes/origin/HEAD"]).replace(/^refs\/remotes\/origin\//, "");
   if (isValidBranchName(b)) return b;
   const show = gitOut(root, ["remote", "show", "origin"]);
   const m = show.match(/HEAD branch:\s*(\S+)/);
   if (m && isValidBranchName(m[1])) return m[1];
-  if (!m) return "main"; // origin 없음 — 기존 규칙 그대로
+  if (!m) return "main"; // no origin: keep the existing rule
   const local = gitOut(root, ["symbolic-ref", "--short", "HEAD"]);
   const fallback = isValidBranchName(local) ? local : "main";
-  warn?.(`⚠️  원격 기본 브랜치를 확인할 수 없어(빈 원격 레포 등) 릴리스 브랜치를 '${fallback}'(으)로 가정합니다.${hint ? ` ${hint}` : ""}`);
+  warn?.(tr("core.detectFs.defaultBranchWarn", { fallback, hint: hint ? ` ${hint}` : "" }));
   return fallback;
 }
 
-// 레포명 — git remote get-url origin 마지막 세그먼트, 실패 시 폴더명.
+// Repo name: last segment of git remote get-url origin, or the folder name on failure.
 export function detectRepoName(root) {
   const url = gitOut(root, ["remote", "get-url", "origin"]);
   if (url) {
@@ -164,32 +164,32 @@ export function detectRepoName(root) {
   return basename(root);
 }
 
-// Spring application*.yml 탐색
-// find {base} -path "*/src/main/resources/application*.yml" | head -1 의 fs 재귀 구현.
-// 반환: root 기준 상대경로 (예: "server/src/main/resources/application.yml") 또는 "".
+// Spring application*.yml lookup.
+// Recursive fs implementation of: find {base} -path "*/src/main/resources/application*.yml" | head -1
+// Returns a path relative to root (e.g. "server/src/main/resources/application.yml") or "".
 //
-// .yaml도 인정한다. Spring은 .yml/.yaml을 모두 공식 지원하는데 종전 정규식이
-// .yml만 봐서, application.yaml을 쓰는 프로젝트는 이 값이 빈 문자열이 되고 그 결과
-// __APPLICATION_YML_DIR__ 가 치환되지 않은 채 설치됐다.
+// .yaml is accepted too. Spring officially supports both .yml and .yaml, but the old regex only looked
+// for .yml, so projects using application.yaml got an empty string here and __APPLICATION_YML_DIR__
+// was installed unreplaced.
 //
-// 같은 디렉토리에서는 프로파일 없는 기본 파일(application.yml/.yaml)을 우선한다. 파일명 정렬만
-// 쓰면 'application-dev.yml'이 'application.yml'보다 앞서(`-` < `.`) 프로파일 파일이 잡힌다.
+// Within one directory the profile-less base file (application.yml/.yaml) wins. With filename sorting alone,
+// 'application-dev.yml' sorts before 'application.yml' (`-` < `.`) and a profile file would be picked.
 export function findSpringAppYml(root, base = ".") {
   return findSpringConfig(root, base, /^application(-[^/]*)?\.ya?ml$/, /^application\.ya?ml$/);
 }
 
-// src/main/resources 아래에서 pattern에 맞는 설정 파일을 찾는다. basePattern(프로파일 없는 기본 파일)이
-// 나오면 그걸로 확정한다.
+// Finds a config file matching pattern under src/main/resources. Once basePattern (the profile-less base file)
+// turns up, that one is final.
 function findSpringConfig(root, base, pattern, basePattern) {
   const startRel = base === "." ? "" : base;
   const PRUNE = new Set(["node_modules", ".git", "build", ".gradle", "target", ".idea"]);
   let hit = "";
   let hitIsBase = false;
   const walk = (rel, depth) => {
-    if (hitIsBase || depth > 8) return; // 기본 파일을 찾았으면 더 볼 필요가 없다
+    if (hitIsBase || depth > 8) return; // once the base file is found there is no need to look further
     let entries;
     try { entries = readdirSync(join(root, rel), { withFileTypes: true }); } catch { return; }
-    // 정렬로 순회 순서 결정화 (find 순서 플랫폼 편차 제거)
+    // Sort to make traversal order deterministic (removes platform differences in find order)
     for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
       if (hitIsBase) return;
       const childRel = rel ? `${rel}/${e.name}` : e.name;
@@ -198,7 +198,7 @@ function findSpringConfig(root, base, pattern, basePattern) {
         walk(childRel, depth + 1);
       } else if (pattern.test(e.name) && childRel.includes("src/main/resources/")) {
         const isBase = basePattern.test(e.name);
-        // 첫 매치는 일단 채택하고, 이후 기본 파일이 나오면 그걸로 승격한다.
+        // Take the first match for now, and promote to the base file if one turns up later.
         if (!hit || isBase) { hit = childRel; hitIsBase = isBase; }
       }
     }
@@ -207,9 +207,9 @@ function findSpringConfig(root, base, pattern, basePattern) {
   return hit;
 }
 
-// 배포 워크플로우가 application-prod.yml을 만들 리소스 폴더.
-// Spring Initializr 기본 산출물은 application.properties라 yml만 찾으면 빈 값이 되어
-// __APPLICATION_YML_DIR__가 치환되지 않은 채 설치된다. yml → properties → 표준 경로 순으로 정한다.
+// Resource folder where the deploy workflow will create application-prod.yml.
+// Spring Initializr produces application.properties by default, so looking only for yml gives an empty value and
+// __APPLICATION_YML_DIR__ is installed unreplaced. Decided in order: yml, then properties, then the standard path.
 export function findSpringResourcesDir(root, base = ".") {
   const f = findSpringAppYml(root, base)
     || findSpringConfig(root, base, /^application(-[^/]*)?\.properties$/, /^application\.properties$/);
@@ -217,27 +217,27 @@ export function findSpringResourcesDir(root, base = ".") {
   return base === "." ? "src/main/resources" : `${base}/src/main/resources`;
 }
 
-// @wizard 토큰 resolver 세트 생성 — index/interactive 공용.
-// paths: Map<type, path> (모노레포 경로).
-// flutterOptions: resolveFlutterOptions 결과 또는 같은 필드를 가진 context. null이면 Flutter 토큰이
-//   빈 값이라 템플릿 기본값(dart-define, store_only)이 그대로 남는다.
+// Builds the set of @wizard token resolvers, shared by index and interactive.
+// paths: Map<type, path> (monorepo paths).
+// flutterOptions: the resolveFlutterOptions result or a context with the same fields. When null the Flutter tokens
+//   are empty, so the template defaults (dart-define, store_only) remain.
 export function makeResolvers(root, repoName, paths, flutterOptions = null) {
   const springBase = (t) => paths.get(t || "spring") || paths.get("spring") || ".";
   return {
     repo: () => repoName,
-    // 빌드 JDK — 배포 워크플로우 JAVA_VERSION의 기본값. 프로젝트 툴체인을 실측한다.
-    // ⚠️ 빈 문자열을 돌려주면 setEnvLine이 그 줄을 건너뛰어 __JAVA_VERSION__이 그대로 남는다
-    //    (같은 실패 형태). 감지 실패 시 반드시 종전 기본값 21로 폴백한다.
+    // Build JDK: default for the deploy workflow's JAVA_VERSION, measured from the project toolchain.
+    // WARNING: returning an empty string makes setEnvLine skip that line, leaving __JAVA_VERSION__ as is
+    //    (the same failure shape). On detection failure always fall back to the previous default, 21.
     jdk: (t) => detectJdk(root, springBase(t)) || "21",
     "spring-app-yml-dir": (t) => findSpringResourcesDir(root, springBase(t)),
-    // yml이 없는 프로젝트(properties 전용)는 리소스 폴더의 application.yml로 만든다 —
-    // properties 파일 자리에 YAML 내용을 쓰면 설정이 깨진다.
+    // A project without yml (properties only) gets application.yml in the resources folder:
+    // writing YAML content in place of a properties file would break the config.
     "spring-app-yml-path": (t) => findSpringAppYml(root, springBase(t))
       || `${findSpringResourcesDir(root, springBase(t))}/application.yml`,
     "flutter-root": () => paths.get("flutter") || ".",
-    // CI changes job의 경로 필터 — 타입별 프로젝트 루트. 단일 레포·common은 "."(항상 변경됨으로 판정).
+    // Path filter for the CI changes job: the project root per type. Single repos and common use "." (always treated as changed).
     "project-path": (t) => paths.get(t) || ".",
-    // 빈 문자열이면 setEnvLine/setFallbackLine이 줄을 건너뛰어 템플릿 기본값이 남는다.
+    // An empty string makes setEnvLine/setFallbackLine skip the line, so the template default remains.
     "flutter-env-mode": () => flutterOptions?.envMode || "",
     "android-deploy-mode": () => flutterOptions?.androidDeployMode || "",
     "ios-deploy-mode": () => flutterOptions?.iosDeployMode || "",