project-auto-wizard 0.13.3 → 0.15.0

package/src/core/paths-resolve.js

@@ -1,37 +1,38 @@
-// 타입별 프로젝트 경로 감지·확정. 모노레포에서 각 타입의 버전 파일이
-// 어느 폴더에 있는지 5단계 우선순위로 확정한다.
+// Per-type project path detection and confirmation. In a monorepo, decides which folder holds each
+// type's version file using a 5-step priority.
 //
-// io 주입 계약(readline-engine 시그니처 그대로):
+// io injection contract (same as the readline-engine signatures):
 //   io.select({message, options:[{value,label}]}) → value | CANCEL(symbol)
 //   io.text({message, defaultValue})              → string | CANCEL
 //   io.confirm({message, initialValue})           → bool | CANCEL
-//   io.log(line)                                   → 안내 출력 (없으면 stderr)
+//   io.log(line)                                   → notice output (stderr when absent)
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { markerForType as baseMarkerForType, resolveMarker } from "./detect.js";
 import { TYPES, typeInfo } from "./types.js";
 import { normalizePath, isRepoRelativePath } from "./paths.js";
 import { CliError } from "./errors.js";
+import { t as tr } from "../i18n/index.js";
 
-// 취소(ESC)는 CANCEL 심볼(Ctrl+C는 엔진이 예외로 중단시킨다) — ui를 import하지 않고 심볼 여부로만 판정 (core→ui 역참조 방지)
+// Cancel (ESC) is the CANCEL symbol (the engine aborts on Ctrl+C with an exception); judged only by being a symbol, without importing ui (avoids a core-to-ui back reference).
 const isCancel = (v) => typeof v === "symbol";
 
-// 타입의 대표 마커 파일명.
-// detect.js는 미지 타입에 package.json을 기본 반환하지만, 경로 탐색에서는 마커가 없는 타입(basic 등)을 빈 문자열로 구분해야 해서 래핑한다.
+// A type's representative marker file name.
+// detect.js returns package.json by default for unknown types, but path search must tell marker-less types (basic etc.) apart with an empty string, hence the wrapper.
 const KNOWN_MARKER_TYPES = new Set(TYPES.filter((t) => t.markers.length).map((t) => t.id));
 export function markerForType(type) {
   return KNOWN_MARKER_TYPES.has(type) ? baseMarkerForType(type) : "";
 }
 
-// 디렉토리에 실재하는 마커 파일명 반환 — resolveMarker의 fs 구동판.
-// (보조 마커 포함: spring build.gradle/.kts/pom.xml, python pyproject/setup.py/requirements.txt)
+// Returns the marker file name that really exists in a directory: the fs-driven version of resolveMarker.
+// (including secondary markers: spring build.gradle/.kts/pom.xml, python pyproject/setup.py/requirements.txt)
 export function existingMarkerInDir(type, dir) {
-  if (!markerForType(type)) return ""; // 미지 타입은 빈 문자열
+  if (!markerForType(type)) return ""; // empty string for unknown types
   return resolveMarker(type, (n) => existsSync(join(dir, n)));
 }
 
-// maxdepth 3 재귀 파일 탐색 — 매치 파일의 "디렉토리" 상대경로(루트는 ".")를 수집.
-// find의 maxdepth는 파일 경로 컴포넌트 수 기준(./a/b/f = depth 3)이므로 동일하게 계산.
+// Recursive file search with maxdepth 3: collects the relative "directory" path of matching files (root is ".").
+// find's maxdepth counts file path components (./a/b/f = depth 3), so it is computed the same way.
 function walkFindDirs(root, { prune, match, maxDepth = 3 }) {
   const hits = [];
   const walk = (rel, depth) => {
@@ -41,37 +42,37 @@ function walkFindDirs(root, { prune, match, maxDepth = 3 }) {
       const childDepth = depth + 1;
       const childRel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        // prune 폴더는 하위 전체 제외
+        // prune folders are excluded along with everything below them
         if (prune.has(e.name)) continue;
-        // 자식 파일이 depth ≤ maxDepth 안에 들어올 때만 하강
+        // descend only when child files fall within depth <= maxDepth
         if (childDepth < maxDepth) walk(childRel, childDepth);
-        // childDepth === maxDepth-0 인 디렉토리 내부 파일은 depth maxDepth+1 → find가 안 봄
-        else if (childDepth === maxDepth) { /* 파일만 maxDepth까지 — 디렉토리 하강 불필요 */ }
+        // files inside a directory at childDepth === maxDepth are at depth maxDepth+1, which find does not see
+        else if (childDepth === maxDepth) { /* files count only up to maxDepth; no need to descend into directories */ }
       } else if (childDepth <= maxDepth && match(e.name)) {
         hits.push(rel === "" ? "." : rel);
       }
     }
   };
   walk("", 0);
-  return [...new Set(hits)].sort(); // 중복 제거 + 정렬
+  return [...new Set(hits)].sort(); // dedupe + sort
 }
 
-// 타입별 마커 파일 후보 검색.
-// 반환: 후보 디렉토리 상대경로 배열 (루트는 ".").
+// Marker-file candidate search per type.
+// Returns an array of candidate directory relative paths (root is ".").
 export function findTypePathCandidates(root, type) {
-  // ── Spring 멀티모듈: settings.gradle(.kts) 폴더 = 모듈 루트로 축약 ──
-  // version_manager가 그 폴더 아래 build.gradle 전부를 갱신하므로 하위 모듈을 펼치지 않는다.
-  // android/ 의 settings.gradle(Flutter/RN)은 spring이 아니므로 prune.
+  // -- Spring multi-module: the settings.gradle(.kts) folder collapses to the module root --
+  // version_manager updates every build.gradle beneath that folder, so submodules are not expanded.
+  // The settings.gradle under android/ (Flutter/RN) is not spring, so it is pruned.
   if (type === "spring") {
     const mm = walkFindDirs(root, {
       prune: new Set(["node_modules", ".git", "build", "dist", ".gradle", "android", "ios"]),
       match: (n) => n === "settings.gradle" || n === "settings.gradle.kts",
     });
     if (mm.length) return mm;
-    // settings.gradle 없음 → 단일 모듈, 아래 build.gradle 폴백
+    // no settings.gradle: single module, fall back to build.gradle below
   }
 
-  // 레지스트리의 마커 순서가 곧 우선순위다 (대표 파일 먼저).
+  // The marker order in the registry is the priority (representative file first).
   const names = typeInfo(type)?.markers;
   if (!names?.length) return [];
 
@@ -79,7 +80,7 @@ export function findTypePathCandidates(root, type) {
     "node_modules", ".git", "build", "dist", ".dart_tool", "android", "ios",
     ".gradle", "venv", ".venv", "__pycache__",
   ]);
-  // 우선순위 높은 마커에서 발견되면 그것만 사용
+  // If found with a higher-priority marker, use only that
   let found = [];
   for (const n of names) {
     found = walkFindDirs(root, { prune, match: (name) => name === n });
@@ -88,43 +89,43 @@ export function findTypePathCandidates(root, type) {
 
   return found.filter((d) => {
     if (type === "flutter") {
-      // example/ 제외 + lib/ 동반 확인 — 오탐 방지
+      // exclude example/ and require a sibling lib/ to avoid false positives
       if (d.includes("example")) return false;
       const libDir = d === "." ? join(root, "lib") : join(root, d, "lib");
       if (!existsSync(libDir)) return false;
     }
     if (type === "spring") {
-      // Flutter/RN의 android/build.gradle 오탐 제외
+      // exclude the false positive of Flutter/RN's android/build.gradle
       if (d.includes("android")) return false;
     }
     return true;
   });
 }
 
-// 선택된 모든 타입의 경로를 감지·확인하여 Map<type,path> 확정
-// (5단계 우선순위).
-//   ① paths에 이미 있음(--paths) → 유지
-//   ② 루트에 마커 존재 → "." 자동
-//   ③ existingPaths(version.yml 저장값)
-//   ④ 후보 스캔
-//   ⑤ 분기 — 비대화형: 기존값→후보1개→에러 / 대화형: 확인·선택·직접입력
+// Detects and confirms the paths of all selected types into a Map<type,path>
+// (5-step priority).
+//   1. already in paths (--paths): kept
+//   2. marker exists at the root: "." automatically
+//   3. existingPaths (value saved in version.yml)
+//   4. candidate scan
+//   5. branch - non-interactive: existing value, then a single candidate, then error / interactive: confirm, select, enter manually
 export async function resolveProjectPaths({
   root, types = [], paths = new Map(), existingPaths = new Map(),
   force = false, tty = true, io = {},
 }) {
   const say = io.log || ((m) => process.stderr.write(`${m}\n`));
-  const result = new Map(paths); // --paths 사전값 유지 (호출부 Map은 불변)
-  const targets = types.filter((t) => t !== "basic"); // basic은 경로 불필요
+  const result = new Map(paths); // keep the pre-set --paths values (the caller's Map is left unchanged)
+  const targets = types.filter((t) => t !== "basic"); // basic needs no path
   if (targets.length === 0) return result;
 
   const total = targets.length;
-  // ── 도입부 안내 (감지 결과 + 무엇을 할지 설명) ──
+  // -- Intro notice (detection result + what will happen) --
   say("");
-  if (total > 1) say(`🔍 멀티타입 프로젝트가 감지되었습니다 — 총 ${total}개 타입`);
-  else say(`🔍 ${targets[0]} 프로젝트가 감지되었습니다 — 총 1개 타입`);
+  if (total > 1) say(tr("core.paths.intro.multi", { total }));
+  else say(tr("core.paths.intro.single", { type: targets[0] }));
   for (const t of targets) say(`   • ${t.padEnd(8)} → ${existingMarkerInDir(t, root)}`);
   say("");
-  say("💡 '프로젝트 루트' = 그 타입의 버전 파일이 있는 폴더 (레포 루트 기준 상대경로)");
+  say(tr("core.paths.intro.rootDef"));
   say("");
 
   let idx = 0;
@@ -132,133 +133,134 @@ export async function resolveProjectPaths({
     idx += 1;
     const prog = `[${idx}/${total}]`;
 
-    // ① --paths 등으로 이미 지정됨 → 최우선
+    // 1. already given via --paths etc.: highest priority
     if (result.get(t)) {
       const p = result.get(t);
       if (!existsSync(join(root, p))) {
-        throw new CliError(`--paths로 지정한 경로가 존재하지 않습니다: '${t}=${p}'`);
+        throw new CliError(tr("core.paths.err.pathMissing", { type: t, path: p }));
       }
-      say(`  ${t} → ${p} (--paths 지정)`);
-      // 막지는 않는다(마커 없이 쓰는 구성도 있다) — 오타로 엉뚱한 폴더를 준 경우를 알린다.
+      say(tr("core.paths.say.explicit", { type: t, path: p }));
+      // Not blocking (some setups work without the marker); this only flags a typo that pointed to the wrong folder.
       const pm = existingMarkerInDir(t, join(root, p));
       if (pm && !existsSync(join(root, p, pm))) {
-        say(`  ⚠️ ${p}에 ${t} 프로젝트 파일(${pm})이 없습니다 — 경로가 맞는지 확인하세요.`);
+        say(tr("core.paths.warn.noMarker", { path: p, type: t, marker: pm }));
       }
       continue;
     }
 
-    // ② 루트에 마커 존재 → "." 자동 확정 (보조 마커 포함)
+    // 2. marker exists at the root: "." confirmed automatically (including secondary markers)
     const rootMarker = existingMarkerInDir(t, root);
     if (rootMarker && existsSync(join(root, rootMarker))) {
       result.set(t, ".");
-      say(`  ${t} → . (루트의 ${rootMarker})`);
+      say(tr("core.paths.say.rootMarker", { type: t, marker: rootMarker }));
       continue;
     }
 
-    // ③ 기존 version.yml 저장값 → 기본 제안값
+    // 3. value saved in the existing version.yml: default suggestion
     const existing = existingPaths.get(t) || "";
 
-    // ④ 후보 검색
+    // 4. candidate search
     const candidates = findTypePathCandidates(root, t);
     let chosen = "";
 
-    // ── ⑤-a 비대화형 (--force 또는 TTY 없음 — root 폴백 의도적 불포함) ──
+    // -- 5a. non-interactive (--force or no TTY; root fallback intentionally excluded) --
     if (force || !tty) {
       if (existing) {
         chosen = existing;
-        say(`  ${t} → ${chosen} (기존 project_paths 유지)`);
+        say(tr("core.paths.say.keepExisting", { type: t, path: chosen }));
       } else if (candidates.length === 1) {
         chosen = candidates[0];
-        say(`  ${t} → ${chosen} (자동 감지)`);
+        say(tr("core.paths.say.auto", { type: t, path: chosen }));
       } else if (candidates.length === 0) {
-        throw new CliError(`${t}: 프로젝트 경로를 찾지 못했습니다. --paths "${t}=경로"로 직접 지정하세요.`);
+        throw new CliError(tr("core.paths.err.none", { type: t }));
       } else {
-        throw new CliError(`${t}: 경로 후보가 ${candidates.length}개로 모호합니다(${candidates.join(", ")}). --paths "${t}=경로"로 직접 지정하세요.`);
+        throw new CliError(tr("core.paths.err.ambiguous", { type: t, count: candidates.length, list: candidates.join(", ") }));
       }
       result.set(t, chosen);
       continue;
     }
 
-    // ── ⑤-b 대화형: 후보 개수별 분기 ──
+    // -- 5b. interactive: branch by candidate count --
     if (candidates.length === 1) {
       const cand = candidates[0];
       const candMarker = existingMarkerInDir(t, cand === "." ? root : join(root, cand));
       const candFull = cand === "." ? candMarker : `${cand}/${candMarker}`;
       say("");
-      say(`  ${prog} 🔍 ${t} — ${candMarker} 발견`);
-      say(`      위치: <레포루트>/${candFull}`);
-      // '아니오'/취소 시 chosen 미설정 → 아래 직접입력 루프로
+      say(tr("core.paths.found.one", { prog, type: t, marker: candMarker }));
+      say(tr("core.paths.found.location", { file: candFull }));
+      // On 'No'/cancel chosen stays unset, falling through to the manual-entry loop below
       const ok = await io.confirm({
-        message: `  ${t} 프로젝트 루트를 '${cand}'(으)로 설정할까요? (${candFull} 기준 — 아니오 선택 시 직접 입력)`,
+        message: tr("core.paths.confirm.candidate", { type: t, cand, file: candFull }),
         initialValue: true,
       });
       if (ok === true) chosen = cand;
     } else if (candidates.length > 1) {
       say("");
-      say(`  ${prog} 🔍 ${t}: 경로 후보 ${candidates.length}개 발견`);
-      // 후보들 + '직접 입력' 메뉴 — value 자체를 한국어로 (센티넬 노출 방지)
+      say(tr("core.paths.found.many", { prog, type: t, count: candidates.length }));
+      // Candidates + a 'manual entry' menu: the value itself is the display text (avoids exposing a sentinel)
+      const manual = tr("core.paths.manualInput");
       const options = candidates.map((c) => ({
         value: c,
         label: `${c} (${existingMarkerInDir(t, c === "." ? root : join(root, c))})`,
       }));
-      options.push({ value: "직접 입력", label: "직접 입력" });
-      const sel = await io.select({ message: `  ${t} 프로젝트 루트를 선택하세요`, options });
-      // ESC(취소)도 직접 입력으로 폴백
-      if (!isCancel(sel) && sel != null && sel !== "직접 입력") chosen = sel;
+      options.push({ value: manual, label: manual });
+      const sel = await io.select({ message: tr("core.paths.select.root", { type: t }), options });
+      // ESC (cancel) also falls back to manual entry
+      if (!isCancel(sel) && sel != null && sel !== manual) chosen = sel;
     } else {
       say("");
-      say(`  ⚠️ ${prog} ${t}: 프로젝트를 찾지 못했습니다 (maxdepth 3).`);
+      say(tr("core.paths.found.none", { prog, type: t }));
     }
 
-    // ── 직접 입력 루프 (위에서 미확정 시) ──
+    // -- Manual-entry loop (when still undecided above) --
     while (!chosen) {
       const hintMarker = existingMarkerInDir(t, root);
-      let prompt = `  ${t} 프로젝트 루트 경로 입력 (${hintMarker} 이 있는 폴더, 예: server, app — 루트면 그냥 Enter`;
-      if (existing) prompt += `, 현재값: ${existing}`;
+      let prompt = tr("core.paths.prompt.base", { type: t, marker: hintMarker });
+      if (existing) prompt += tr("core.paths.prompt.current", { existing });
       prompt += "): ";
       let input = await io.text({ message: prompt, defaultValue: "" });
-      if (isCancel(input) || input == null) input = ""; // ESC → 빈값 (아래 폴백)
+      if (isCancel(input) || input == null) input = ""; // ESC becomes empty (falls back below)
       input = String(input).trim();
-      // 빈값 → 기존값 또는 루트 — normalizePath 전에 판정
+      // Empty means the existing value or the root; decided before normalizePath
       input = input === "" ? (existing || ".") : normalizePath(input);
       if (!isRepoRelativePath(input)) {
-        say(`  ⚠️ '${input}'은(는) 레포 밖 경로입니다 — 레포 루트 기준 상대경로로 입력하세요.`);
+        say(tr("core.paths.warn.outsideRepo", { input }));
         continue;
       }
-      // 검증: 입력 경로에 마커 존재 확인 (보조 마커 포함)
+      // Validation: confirm a marker exists at the entered path (including secondary markers)
       const m = existingMarkerInDir(t, input === "." ? root : join(root, input));
       if (m && existsSync(join(root, input === "." ? "" : input, m))) {
         chosen = input;
       } else {
-        say(`  ⚠️ ${input}/${m} 파일이 없습니다.`);
-        // 기본(Enter)·ESC는 이 경로를 그대로 쓴다 — 기본을 '아니오'로 두면 마커가 아직 없는 타입
-        // (프로젝트 생성 전에 미리 추가한 타입 등)은 Enter만으로는 빠져나갈 수 없었다.
-        // 다시 입력하려면 '아니오'를 명시적으로 고른다. 경로는 version.yml project_paths에서 나중에 고칠 수 있다.
-        const forceOk = await io.confirm({ message: "  그래도 이 경로를 사용할까요? (아니오 = 다시 입력)", initialValue: true });
+        say(tr("core.paths.warn.noFile", { input, marker: m }));
+        // Default (Enter) and ESC keep this path as is. With 'No' as the default, a type whose marker does not exist yet
+        // (e.g. added before the project is created) could not be exited with Enter alone.
+        // To enter it again, explicitly choose 'No'. The path can be fixed later in version.yml project_paths.
+        const forceOk = await io.confirm({ message: tr("core.paths.confirm.useAnyway"), initialValue: true });
         if (forceOk !== false) chosen = input;
       }
     }
 
     result.set(t, chosen);
-    say(`  ✅ ${t} → ${chosen}`);
+    say(tr("core.paths.say.chosen", { type: t, chosen }));
   }
 
-  // ── 요약 + 같은 마커 파일 중복 경고 ──
+  // -- Summary + duplicate-marker-file warning --
   say("");
-  say("📂 타입별 버전 파일 경로 확정:");
-  const fileToTypes = new Map(); // 마커 파일 상대경로 → 그 파일을 쓰는 타입들
+  say(tr("core.paths.summary.title"));
+  const fileToTypes = new Map(); // marker file relative path to the types using that file
   for (const [pt, pp] of result) {
     const m = existingMarkerInDir(pt, pp === "." ? root : join(root, pp));
     const file = pp === "." ? m : `${pp}/${m}`;
-    say(`   ${pt} → ${file}`);
+    say(tr("core.paths.summary.row", { type: pt, file }));
     if (!fileToTypes.has(file)) fileToTypes.set(file, []);
     fileToTypes.get(file).push(pt);
   }
   for (const [file, ts] of fileToTypes) {
     if (ts.length > 1) {
-      // 멱등 동작이라 막지는 않고 경고만
-      say(`  ⚠️ 같은 파일(${file})을 여러 타입(${ts.join(" ")})이 바라봅니다.`);
-      say("     → sync 때 모두 같은 버전이 기록됩니다. 동작에는 문제없지만 의도한 구성인지 확인하세요.");
+      // Idempotent behavior, so only a warning rather than a block
+      say(tr("core.paths.dup.warn", { file, types: ts.join(" ") }));
+      say(tr("core.paths.dup.note"));
     }
   }
   say("");

package/src/core/paths.js

@@ -1,4 +1,4 @@
-// 경로 상수 — 설치 대상(사용자 레포) 경로 + payload 내부 레이아웃.
+// Path constants: install target (user repo) paths plus the payload's internal layout.
 import { join } from "node:path";
 
 export const PATHS = {
@@ -7,15 +7,15 @@ export const PATHS = {
   scriptsDir: ".github/scripts",
 };
 
-// payload/ 내부 레이아웃 (payload 단일 진실)
+// Layout inside payload/ (payload is the single source of truth)
 export const PAYLOAD = {
   workflowsDir: "workflows",   // payload/workflows/{common,spring,flutter,...}
   scriptsDir: "scripts",       // payload/scripts/*.py
-  configDir: "config",         // payload/config/wizard-prompts.yml 등 (마법사 런타임용)
+  configDir: "config",         // payload/config/wizard-prompts.yml etc. (for the wizard runtime)
 };
 
-// 타입 하나의 워크플로우 원본 폴더 [타입 직하위, server-deploy 하위] — 존재 여부는 호출부가 확인한다.
-// 설치·충돌 조사·미리보기·배포 방식 판정이 같은 폴더 구성을 봐야 결과가 서로 어긋나지 않는다.
+// Source workflow folders of one type [directly under the type, under server-deploy]; callers check existence.
+// Install, conflict scan, preview and deploy-style detection must all see the same folder layout so their results do not diverge.
 export function typeWorkflowDirs(payloadRoot, type) {
   const typeDir = join(payloadRoot, PAYLOAD.workflowsDir, type);
   return [typeDir, join(typeDir, "server-deploy")];
@@ -24,17 +24,17 @@ export function typeWorkflowDirs(payloadRoot, type) {
 export const WORKFLOW_PREFIX = "PROJECT";
 export const WORKFLOW_COMMON_PREFIX = "PROJECT-COMMON";
 
-// 경로 정규화: 앞뒤 공백·\→/·끝 /·앞 ./ 제거, 빈값→"."
+// Path normalization: strips surrounding whitespace, converts \ to /, removes a trailing / and a leading ./, empty becomes "."
 export function normalizePath(p) {
   let s = String(p).trim();
   s = s.replace(/\\/g, "/");
-  s = s.replace(/\/+$/, "");   // 끝 /
-  s = s.replace(/^\.\//, "");  // 앞 ./
+  s = s.replace(/\/+$/, "");   // trailing /
+  s = s.replace(/^\.\//, "");  // leading ./
   return s === "" ? "." : s;
 }
 
-// 정규화된 경로가 레포 안(상대경로, '..' 없음)인가. 레포 밖을 가리키면 설치 파일(fastlane 등)이
-// 옆 레포에 만들어지고 워크플로우 paths 필터도 동작하지 않는다.
+// Whether a normalized path stays inside the repo (relative, no '..'). A path pointing outside would create the
+// installed files (fastlane etc.) in a neighboring repo, and the workflow paths filter would not work either.
 export function isRepoRelativePath(p) {
   if (/^\//.test(p) || /^[A-Za-z]:/.test(p)) return false;
   return !p.split("/").includes("..");

package/src/core/release-options.js

@@ -1,8 +1,8 @@
-// 릴리스 옵션(semver_auto·copilot_ai) 값 결정 규칙 — 비대화형(index.js)과 대화형(interactive.js)이 공유한다.
-// 우선순위: 명시값(CLI 플래그·질문 답변) → version.yml 저장값 → 기본값. 경로마다 따로 두면
-// 같은 레포가 실행 방식에 따라 다른 설정으로 설치된다.
+// Value-decision rules for the release options (semver_auto, copilot_ai), shared by non-interactive (index.js) and interactive (interactive.js) modes.
+// Priority: explicit value (CLI flag, prompt answer), then the value saved in version.yml, then the default.
+// Keeping separate copies per path would install the same repo with different settings depending on how it was run.
 
-// 명시값과 저장값만 반영한다 — null이면 아직 정해지지 않은 것(대화형은 이 값으로 질문 여부를 가른다).
+// Reflects only explicit and saved values. null means not decided yet (interactive mode uses it to decide whether to ask).
 export function pickReleaseOptions(explicit = {}, existing = null) {
   return {
     semverAuto: explicit.semverAuto ?? existing?.options?.semverAuto ?? null,
@@ -10,10 +10,10 @@ export function pickReleaseOptions(explicit = {}, existing = null) {
   };
 }
 
-// 최종값 — 정해지지 않은 옵션에 기본값을 채운다.
-// semver_auto: 신규 설치만 true. 기존 version.yml에 키가 없던 설치(기능 추가 이전 설치)가 조용히 켜지면
-//   애매한 커밋 하나로 major가 승격될 수 있어 false로 둔다.
-// copilot_ai: AI Credits를 소비하는 opt-in이라 신규·기존 모두 명시하지 않으면 false.
+// Final values: fills undecided options with defaults.
+// semver_auto: true only for fresh installs. If an existing install whose version.yml lacked the key (installed
+//   before the feature existed) were switched on silently, one ambiguous commit could promote a major bump, so it stays false.
+// copilot_ai: an opt-in that consumes AI credits, so it is false for both new and existing installs unless stated.
 export function resolveReleaseOptions(explicit = {}, existing = null) {
   const { semverAuto, copilotAi } = pickReleaseOptions(explicit, existing);
   return {

package/src/core/removal-exec.js

@@ -1,5 +1,5 @@
-// uninstall·purge 공통 삭제 실행부 — 두 명령은 옵션을 삭제 계획으로 바꾸기만 하고,
-// 실제 삭제와 기록은 여기서 한 번에 처리한다. 대상 판별은 removal-plan.js(읽기 전용)가 맡는다.
+// Shared removal executor for uninstall and purge - the two commands only turn options into a removal plan,
+// and the actual deletion and logging happen here in one place. Target detection is done by removal-plan.js (read-only).
 import { join, posix } from "node:path";
 import { readdirSync, rmdirSync } from "node:fs";
 import { PATHS } from "./paths.js";
@@ -7,9 +7,10 @@ import { remove } from "./fsutil.js";
 import { removeVersionSectionFromReadme } from "./copy/readme.js";
 import { removeAutoAddedEntriesFromGitignore } from "./copy/gitignore.js";
 import { logRemovals } from "./logger.js";
+import { t } from "../i18n/index.js";
 
-// 파일을 지운 뒤 비게 된 상위 폴더를 레포 루트 직전까지 정리한다(마법사가 만든 fastlane/ 등).
-// 비어 있지 않은 폴더를 만나면 멈추므로 사용자 파일이 남은 폴더는 건드리지 않는다.
+// After deleting files, clean up the parent folders that became empty, up to just below the repo root (fastlane/ etc. made by the wizard).
+// It stops at the first non-empty folder, so folders still holding user files are left alone.
 export function pruneEmptyDirs(targetRoot, relDir) {
   let rel = relDir;
   while (rel && rel !== "." && rel !== "/") {
@@ -22,8 +23,8 @@ export function pruneEmptyDirs(targetRoot, relDir) {
   }
 }
 
-// Flutter 앱 파일 제거 — 미수정분만 plan에 들어오므로 그대로 지우고 빈 폴더를 정리한다.
-// 로그는 삭제가 끝난 뒤 한꺼번에 남기므로 기록할 항목을 done에 모은다.
+// Remove Flutter app files - only unmodified ones enter the plan, so delete them as-is and tidy empty folders.
+// Logs are written all at once after deletion finishes, so entries to record are collected in done.
 export function removeAppFiles(targetRoot, appFiles, done = []) {
   for (const rel of appFiles) {
     remove(join(targetRoot, rel));
@@ -32,17 +33,17 @@ export function removeAppFiles(targetRoot, appFiles, done = []) {
   }
 }
 
-// 설치물을 지운 뒤 비게 된 .github/workflows·.github/scripts(와 .github)를 정리한다.
-// 이번에 그 폴더에서 무언가를 지웠을 때만 — 원래 비어 있던 폴더까지 손대지 않는다.
+// Clean up .github/workflows and .github/scripts (and .github) that became empty after removing installed files.
+// Only when something was deleted from that folder this run - folders that were empty to begin with are not touched.
 export function pruneInstallDirs(targetRoot, plan) {
   if (plan.workflows.length || plan.baseline?.length) pruneEmptyDirs(targetRoot, PATHS.workflowsDir);
   if (plan.scripts.length) pruneEmptyDirs(targetRoot, PATHS.scriptsDir);
 }
 
-// plan: { workflows, scripts, appFiles, baseline, versionYml, readme, gitignore, changelog } — 모두 "삭제 대상" 여부/목록.
-// options.logOrder: 뒤쪽 항목(version·readme·gitignore·changelog)의 기록 순서 — 명령마다 기존 순서를 유지한다.
-// options.gitignoreDetail(status): .gitignore 기록 문구. null을 돌려주면 기록하지 않는다.
-// 반환: 실제로 제거된 결과 — readme/gitignore는 plan이 대상으로 봤어도 안전하게 포기(skip-*)될 수 있어 실제 결과로 덮어쓴다.
+// plan: { workflows, scripts, appFiles, baseline, versionYml, readme, gitignore, changelog } - each is a "to delete" flag/list.
+// options.logOrder: record order of the trailing entries (version, readme, gitignore, changelog) - each command keeps its existing order.
+// options.gitignoreDetail(status): the .gitignore log text. Returning null means nothing is recorded.
+// Returns: what was actually removed - readme/gitignore may be safely given up (skip-*) even if the plan targeted them, so the actual result overrides.
 export function executeRemoval(targetRoot, plan, { logOrder, gitignoreDetail }) {
   const wfDir = join(targetRoot, PATHS.workflowsDir);
   const done = [];
@@ -58,7 +59,7 @@ export function executeRemoval(targetRoot, plan, { logOrder, gitignoreDetail })
   const gitignore = gitignoreStatus === "removed" || gitignoreStatus === "file-deleted";
   if (plan.versionYml) { remove(join(targetRoot, PATHS.versionFile)); entries.version.push(["remove", "version", PATHS.versionFile]); }
   for (const f of plan.changelog || []) { remove(join(targetRoot, f)); entries.changelog.push(["remove", "changelog", f]); }
-  if (readme) entries.readme.push(["remove", "readme", "README.md 버전 섹션"]);
+  if (readme) entries.readme.push(["remove", "readme", t("core.removalExec.readmeSection")]);
   const detail = gitignoreStatus && gitignoreDetail(gitignoreStatus);
   if (detail) entries.gitignore.push(["remove", "gitignore", detail]);
   for (const k of logOrder) done.push(...entries[k]);