project-auto-wizard 0.13.3 → 0.14.0

package/src/core/detect.js

@@ -1,10 +1,11 @@
+import { t as tr } from "../i18n/index.js";
 import {
   typeInfo, FALLBACK_TYPE, MARKER_DETECTED_TYPES, PACKAGE_DETECTED_TYPES, PACKAGE_FALLBACK_TYPE,
 } from "./types.js";
 
-// package.json 분류 — 의존성 "키"를 정확히 비교한다. 원문 부분문자열로 보면 export 스크립트나
-// exponential-backoff가 expo로, react-native-web을 쓰는 웹앱이 react-native로, keywords의 "next"가
-// next로 오감지된다. 입력은 package.json 원문 문자열(raw). 판정 순서는 레지스트리의 detectOrder.
+// 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.
 export function classifyPackageText(raw) {
   let pkg;
   try { pkg = JSON.parse(String(raw || "")); } catch { return PACKAGE_FALLBACK_TYPE; }
@@ -17,14 +18,14 @@ export function classifyPackageText(raw) {
   return PACKAGE_DETECTED_TYPES.find((t) => deps.has(t.packageDep))?.id ?? PACKAGE_FALLBACK_TYPE;
 }
 
-// 편의: 파싱된 객체를 받는 경우 원문으로 재직렬화해 위 규칙 적용
+// Convenience: when given a parsed object, re-serialize it and apply the rule above.
 export function classifyPackageJson(pkgOrRaw) {
   const raw = typeof pkgOrRaw === "string" ? pkgOrRaw : JSON.stringify(pkgOrRaw || {});
   return classifyPackageText(raw);
 }
 
-// 마커 스캔. has(relpath)=>bool 주입. node는 다른 타입 있으면 미추가.
-// read(relpath)=>string|null 로 package.json 원문을 받아 classifyPackageText에 넘긴다.
+// Marker scan. has(relpath)=>bool is injected. node is not added when another type is present.
+// read(relpath)=>string|null supplies the raw package.json passed to classifyPackageText.
 export function detectTypesFromMarkers({ has, read }) {
   const types = [];
   for (const t of MARKER_DETECTED_TYPES) if (t.markers.some(has)) types.push(t.id);
@@ -36,25 +37,25 @@ export function detectTypesFromMarkers({ has, read }) {
   return types.length ? [...new Set(types)] : [FALLBACK_TYPE];
 }
 
-// 1.2.3-rc.1·1.2.3+7·1.2.0-SNAPSHOT 같은 prerelease/빌드 메타데이터는 x.y.z 코어만 쓴다.
-// version.yml은 x.y.z만 받으므로 감지 실패(0.0.1)로 떨어지는 것보다 코어가 정확하다.
-// 릴리스 시 읽기(payload/scripts/version_manager.py core_version)와 같은 규칙이어야 설치 직후 값이 유지된다.
+// For prerelease/build metadata such as 1.2.3-rc.1, 1.2.3+7, 1.2.0-SNAPSHOT only the x.y.z core is used.
+// version.yml accepts only x.y.z, so the core is more accurate than falling back to 0.0.1.
+// Must match the release-time read (payload/scripts/version_manager.py core_version) so the value survives right after install.
 function coreVersion(v) {
   const m = String(v ?? "").trim().match(/^v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.+-]*)?$/);
   return m ? m[1] : null;
 }
 
-// setup.py의 setup(version="x.y.z"). python_version 같은 다른 키는 단어 경계로 거른다.
+// setup(version="x.y.z") in setup.py. Other keys such as python_version are filtered out by the word boundary.
 export function versionFromSetupPy(content) {
   if (!content) return null;
   const m = String(content).match(/(?<![\w.])version\s*=\s*["']([^"']+)["']/);
   return m ? coreVersion(m[1]) : null;
 }
 
-// React Native 앱 버전 — 릴리스 때 version_manager가 쓰는 파일(ios/<앱>/Info.plist,
-// android/app/build.gradle)에서 읽는다. package.json version은 동기화 대상이 아니라 기준이 되면 어긋난다.
-// $(MARKETING_VERSION) 참조나 템플릿 기본값 "1.0"처럼 x.y.z가 아니면 건너뛴다.
-// list(relDir)=>string[]|null 로 ios 아래 앱 폴더 이름을 받는다(Pods 등 깊은 plist는 보지 않는다).
+// React Native app version: read from the files version_manager writes at release time (ios/<app>/Info.plist,
+// android/app/build.gradle). package.json version is not a sync target, so using it as the source would drift.
+// Values that are not x.y.z, such as a $(MARKETING_VERSION) reference or the template default "1.0", are skipped.
+// list(relDir)=>string[]|null supplies the app folder names under ios (deep plists such as Pods are not inspected).
 export function versionFromReactNative({ read, list }) {
   for (const dir of [...(list?.("ios") || [])].sort()) {
     const m = String(read(`ios/${dir}/Info.plist`) || "").match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]*)<\/string>/);
@@ -65,12 +66,12 @@ export function versionFromReactNative({ read, list }) {
   return m ? coreVersion(m[1]) : null;
 }
 
-// 버전 감지 — 순서대로 첫 성공. read(relpath)=>string|null 주입.
-// package.json은 이미 Node JSON.parse로 파싱을 마친 값이므로 jq 설치 여부와 무관하게 항상 사용한다.
-// hint: 폴백 경고 뒤에 붙일 "그럼 어떻게 고치나" 한 줄. 대화형과 CLI가 서로 다른 방법을
-// 안내해야 하므로 호출부가 정한다. 미지정 시 CLI 문구를 쓴다.
-// types: 주 타입(첫 항목)의 버전 파일을 먼저 읽는다. 릴리스 때 version_manager가 주 타입
-// 파일과 version.yml을 비교하므로, 다른 타입 버전을 잡으면 첫 릴리스에서 버전이 뛴다.
+// Version detection: first success in order. read(relpath)=>string|null is injected.
+// package.json is already parsed with Node JSON.parse, so it is always used regardless of whether jq is installed.
+// hint: one line appended to the fallback warning saying how to fix it. Interactive mode and the CLI
+// suggest different fixes, so the caller decides. The CLI wording is used when omitted.
+// types: the primary type's (first entry) version file is read first. At release time version_manager compares
+// the primary type's file with version.yml, so picking another type's version would make the version jump on the first release.
 export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hint, types = [] }) {
   const grab = (content, re) => {
     for (const line of (content || "").split("\n")) {
@@ -79,17 +80,17 @@ export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hin
     }
     return null;
   };
-  // 줄 시작 앵커가 없으면 ext.kotlin_version 같은 의존성 버전 변수가 먼저 걸린다.
-  // 따옴표로 감싼 값만 본다 — 릴리스 때 동기화가 고칠 수 있는 형태가 이것뿐이다.
+  // Without a line-start anchor, dependency version variables such as ext.kotlin_version match first.
+  // Only quoted values are considered: that is the only form the release-time sync can rewrite.
   const gradleRe = /^(\s*)version\s*=\s*(["'])([^"'\n]*)\2/;
-  // 들여쓰지 않은 `version =`을 우선하고, 없을 때만 allprojects/subprojects 블록 안의 들여쓴 줄을 쓴다.
-  // `node { version = '20.11.0' }` 같은 플러그인 설정 블록이 프로젝트 버전으로 읽히면 첫 릴리스에서 버전이 뛴다.
-  // 릴리스 때의 version_manager.py와 같은 규칙이어야 한다.
-  // 주석을 떼고 따옴표 안 글자는 공백으로 바꾼다 — url 'https://…'의 `//`나 문자열 속 중괄호가
-  // 블록 깊이 계산을 흐트러뜨리지 않게 한다. version_manager.py와 같은 규칙이어야 한다.
-  // quote는 이 줄이 시작될 때 열려 있던 따옴표다. 삼중따옴표(""" ''')는 여러 줄에 걸치므로
-  // { code, quote }로 줄 끝에서 열려 있는 따옴표를 돌려줘 다음 줄이 이어받게 한다.
-  // 한 줄짜리 따옴표는 줄 끝에서 닫힌 것으로 본다.
+  // Prefer a non-indented `version =`; only when none exists use an indented line inside an allprojects/subprojects block.
+  // If a plugin config block such as `node { version = '20.11.0' }` were read as the project version, the version would jump on the first release.
+  // Must follow the same rule as version_manager.py at release time.
+  // Strip comments and blank out characters inside quotes so the `//` in url 'https://...' or braces inside strings
+  // do not throw off the block-depth count. Must follow the same rule as version_manager.py.
+  // quote is the quote that was open when this line started. Triple quotes (""" ''') span several lines, so
+  // { code, quote } returns the quote still open at the end of the line for the next line to continue.
+  // A single-line quote is treated as closed at the end of the line.
   const gradleCode = (line, quote) => {
     let out = "";
     for (let i = 0; i < line.length;) {
@@ -109,7 +110,7 @@ export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hin
   };
   const gradleVersion = (content) => {
     const top = [], shared = [], stack = [];
-    let quote = ""; // 여러 줄 문자열 안이면 그 따옴표. 문자열 속 줄은 코드가 아니다
+    let quote = ""; // the open quote when inside a multi-line string; lines inside a string are not code
     for (const line of (content || "").split("\n")) {
       const m = quote ? null : line.match(gradleRe);
       if (m) {
@@ -131,8 +132,8 @@ export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hin
   const sources = {
     packageJson: () => coreVersion(readJson?.("package.json")?.version),
     appJson: () => coreVersion(readJson?.("app.json")?.expo?.version),
-    // Groovy DSL과 Kotlin DSL은 같은 문법(`version = "x.y.z"`)이라 정규식을 공유한다.
-    // .kts를 빼먹으면 Kotlin DSL Spring 프로젝트가 전부 0.0.1로 초기화된다.
+    // Groovy DSL and Kotlin DSL share the same syntax (`version = "x.y.z"`), so they share the regex.
+    // Omitting .kts would reset every Kotlin DSL Spring project to 0.0.1.
     gradle: () => gradleVersion(read("build.gradle")),
     gradleKts: () => gradleVersion(read("build.gradle.kts")),
     pom: () => versionFromPom(read("pom.xml")),
@@ -150,13 +151,13 @@ export function detectVersionFromFiles({ read, readJson, list, gitTag, warn, hin
     if (v) return v;
   }
   if (gitTag) { const t = coreVersion(gitTag); if (t) return t; }
-  const tail = hint ?? "--project-version으로 직접 지정하거나 version.yml을 확인하세요.";
-  warn?.(`⚠️  버전을 자동 감지하지 못해 기본값 0.0.1을 사용합니다 — ${tail}`);
+  const tail = hint ?? tr("core.detect.versionFallbackHint");
+  warn?.(tr("core.detect.versionFallbackWarn", { tail }));
   return "0.0.1";
 }
 
-// pyproject.toml의 패키지 버전. [tool.*] 등 다른 섹션의 `version =`은 도구 설정이라
-// [project]·[tool.poetry] 섹션 안에서만 읽는다.
+// Package version in pyproject.toml. `version =` in other sections such as [tool.*] is tool config,
+// so it is read only inside the [project] and [tool.poetry] sections.
 export function versionFromPyproject(content) {
   if (!content) return null;
   let section = "";
@@ -170,9 +171,9 @@ export function versionFromPyproject(content) {
   return null;
 }
 
-// Maven pom.xml의 프로젝트 버전 — <project> 바로 아래의 <version>만 본다.
-// <parent>(스프링 부트 BOM)나 <dependencies> 안의 버전은 프로젝트 버전이 아니므로 깊이로 구분한다.
-// 프로젝트 버전이 없으면(부모에서 상속) null — 의존성 버전을 대신 고르지 않는다.
+// Maven pom.xml project version: only the <version> directly under <project> counts.
+// Versions inside <parent> (Spring Boot BOM) or <dependencies> are not the project version, so depth tells them apart.
+// Returns null when there is no project version (inherited from the parent); a dependency version is never picked instead.
 export function versionFromPom(content) {
   if (!content) return null;
   const text = String(content);
@@ -197,42 +198,43 @@ export function versionFromPom(content) {
   return null;
 }
 
-// 타입의 대표 마커 파일. 마커가 없는 타입(basic)·미지 타입은 package.json을 돌려준다.
+// A type's representative marker file. Types without markers (basic) and unknown types return package.json.
 export function markerForType(type) {
   return typeInfo(type)?.markers[0] || "package.json";
 }
 
-// 대표 파일 외의 보조 마커 (예: Spring의 build.gradle.kts·pom.xml).
+// Secondary markers besides the representative file (e.g. Spring's build.gradle.kts and pom.xml).
 export function extraMarkers(type) {
   return typeInfo(type)?.markers.slice(1) || [];
 }
 
-// 그 타입을 감지하는 데 실제로 쓰인 파일. markerForType은 타입당 대표 파일 하나를
-// 고정 반환하므로, build.gradle.kts만 있는 레포에서도 "build.gradle 발견"이라고 출력돼
-// 같은 설치 로그 안에서 경로 확정 화면과 파일명이 어긋났다. has()로 실재하는 것을 고른다.
-// 실재하는 후보가 없으면(감지 전 화면 등) 대표 파일을 쓴다. 단 "근거"로 보여줄 때는(fallback:false)
-// 빈 문자열을 돌려준다 — 직접 고른 타입에 없는 파일을 근거로 붙이면 감지된 것처럼 보인다.
+// The file actually used to detect that type. markerForType always returns one representative file per type,
+// so even a repo with only build.gradle.kts printed "found build.gradle" and the file name disagreed with the
+// path-confirmation screen in the same install log. has() picks the one that really exists.
+// When no candidate exists (e.g. screens before detection) the representative file is used. When shown as
+// "evidence" (fallback:false) an empty string is returned instead: attaching a file that does not exist for a
+// manually chosen type as evidence would make it look detected.
 export function resolveMarker(type, has, { fallback = true } = {}) {
   const candidates = [markerForType(type), ...extraMarkers(type)];
   return candidates.find(has) ?? (fallback ? candidates[0] : "");
 }
 
-// 빌드 JDK 감지 — 배포 워크플로우의 JAVA_VERSION 기본값이 21로 고정돼 있어
-// toolchain이 다른 프로젝트(예: 25)는 그대로 Enter를 누르면 러너 JDK와 어긋나 빌드가 깨진다.
-// 빌드 번호를 프로젝트 파일에서 읽는 detectBuildNumberFromFiles와 같은 방식으로 실측한다.
-// 반환: "21" 같은 메이저 버전 문자열, 못 찾으면 null.
+// Build JDK detection: the deploy workflow's JAVA_VERSION default is fixed at 21, so a project with a
+// different toolchain (e.g. 25) that just presses Enter ends up with a runner JDK mismatch and a broken build.
+// Measured from project files the same way detectBuildNumberFromFiles reads the build number.
+// Returns a major version string such as "21", or null when not found.
 export function detectJdkFromFiles({ read }) {
   const pick = (content, patterns) => {
     if (!content) return null;
     for (const re of patterns) {
       const m = String(content).match(re);
-      // JavaVersion.VERSION_1_8 처럼 1_8 표기는 8로 정규화한다.
+      // Normalize the 1_8 notation (JavaVersion.VERSION_1_8) to 8.
       if (m) return m[1] === "1_8" ? "8" : m[1].replace("1_", "");
     }
     return null;
   };
   const gradlePatterns = [
-    /JavaLanguageVersion\.of\((\d+)\)/,                  // toolchain (Gradle 권장 표기)
+    /JavaLanguageVersion\.of\((\d+)\)/,                  // toolchain (recommended Gradle notation)
     /JavaVersion\.VERSION_(\d+(?:_\d+)?)/,               // sourceCompatibility = JavaVersion.VERSION_21
     /(?:source|target)Compatibility\s*=?\s*["'](\d+)["']/, // sourceCompatibility = '17'
   ];
@@ -246,40 +248,40 @@ export function detectJdkFromFiles({ read }) {
   return null;
 }
 
-// 타입별 실제 마커 파일 맵 — 감지 로그·설치 로그가 같은 근거를 쓰도록 한 곳에서 만든다.
+// Map of the real marker file per type: built in one place so the detection log and install log cite the same evidence.
 export function resolveMarkers(types = [], has) {
   const out = new Map();
   for (const t of types) {
     if (t === "basic") continue;
-    // 실제로 있는 파일만 근거로 삼는다 — 없으면 맵에서 빠져 화면·로그가 "직접 선택"으로 다룬다.
+    // Only files that actually exist count as evidence: otherwise the type is left out of the map and screens/logs treat it as "manually chosen".
     const found = resolveMarker(t, has, { fallback: false });
     if (found) out.set(t, found);
   }
   return out;
 }
 
-// 빌드 번호 감지 — 신규 통합 시 pubspec.yaml/build.gradle/app.json에 이미 기록된
-// 빌드 번호를 읽어 version_code가 항상 1로 초기화되는 걸 막는다. types 배열에서 먼저 매칭되는
-// 첫 타입만 사용한다(다른 감지 로직의 types[0]=primary 관례와 동일). read(rel)=>string|null,
-// readJson(rel)=>object|null 로 주입.
+// Build number detection: on a fresh integration, read the build number already recorded in
+// pubspec.yaml/build.gradle/app.json so version_code is not always reset to 1. Only the first matching
+// type in the types array is used (same types[0]=primary convention as the other detection logic).
+// read(rel)=>string|null and readJson(rel)=>object|null are injected.
 export function detectBuildNumberFromFiles({ types = [], read, readJson, warn }) {
   const tryFlutter = () => {
     const content = read("pubspec.yaml");
     if (content == null) return null;
-    // 1.2.3-rc.1+4처럼 prerelease가 있어도 +N은 빌드 번호다(릴리스 시 읽기와 같은 규칙).
+    // +N is the build number even with a prerelease such as 1.2.3-rc.1+4 (same rule as the release-time read).
     const m = content.match(/^version:\s*\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\+(\d+)/m);
     if (m) return parseInt(m[1], 10);
-    warn?.("⚠️  pubspec.yaml에 빌드 번호(+N)가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.");
+    warn?.(tr("core.detect.buildNumber.pubspecMissing"));
     return null;
   };
   const tryReactNative = () => {
     const content = read("android/app/build.gradle");
     if (content == null) return null;
-    // 앵커 + m 플래그로 한 줄 전체가 "versionCode N"인 라인만 매칭 — 주석 처리된
-    // "// versionCode 2"나 다른 블록의 versionCode 참조에 오매칭되지 않도록 함.
+    // Anchors + the m flag match only lines that are entirely "versionCode N", so a commented-out
+    // "// versionCode 2" or a versionCode reference in another block is not matched by mistake.
     const m = content.match(/^\s*versionCode\s+(\d+)\s*$/m);
     if (m) return parseInt(m[1], 10);
-    warn?.("⚠️  android/app/build.gradle에 versionCode가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.");
+    warn?.(tr("core.detect.buildNumber.gradleMissing"));
     return null;
   };
   const tryExpo = () => {
@@ -287,7 +289,7 @@ export function detectBuildNumberFromFiles({ types = [], read, readJson, warn })
     if (data == null) return null;
     const code = data?.expo?.android?.versionCode;
     if (Number.isInteger(code)) return code;
-    warn?.("⚠️  app.json의 expo.android.versionCode가 없어 version_code를 감지하지 못했습니다 — 기본값 1을 사용합니다. 실제 빌드 번호를 확인하세요.");
+    warn?.(tr("core.detect.buildNumber.expoMissing"));
     return null;
   };
   const readers = { pubspec: tryFlutter, androidGradle: tryReactNative, expoAppJson: tryExpo };

package/src/core/errors.js

@@ -1,3 +1,3 @@
-// 사용자 입력 오류 — 호출부(index.js)가 스택 없이 메시지만 출력하고 exit 1로 끝낸다.
-// core 모듈도 던지므로 cli가 아닌 core에 둔다(core → cli 역참조 방지).
+// User input error - the caller (index.js) prints only the message, no stack, and exits 1.
+// Core modules throw it too, so it lives in core rather than cli (avoids a core -> cli back-reference).
 export class CliError extends Error {}

package/src/core/flutter-doctor.js

@@ -1,19 +1,20 @@
-// Flutter 진단 항목 — doctor가 타입 훅(doctorChecks)으로 호출한다.
+// Flutter diagnostic checks, called by doctor through the type hook (doctorChecks).
 import { existsSync, readFileSync } from "node:fs";
 import { join, posix } from "node:path";
 import { PATHS } from "./paths.js";
 import { STORE_PLATFORMS, STORE_APP_FILES, parseStoreList, storeAppFilesFor } from "./flutter-options.js";
 import { inferInstalledStores } from "./installed-stores.js";
+import { t } from "../i18n/index.js";
 
-const PLATFORM_ROW_NAME = { android: "Flutter Android 배포 파일", ios: "Flutter iOS 배포 파일" };
-const PLACEHOLDER_RE = /__[A-Z][A-Z0-9_]*__/g; // 감지 규칙은 ExportOptions.plist 템플릿·IOS-TESTFLIGHT 검증과 동일
+const PLATFORM_ROW_NAME = { android: "core.flutterDoctor.row.android", ios: "core.flutterDoctor.row.ios" }; // catalog keys, resolved lazily
+const PLACEHOLDER_RE = /__[A-Z][A-Z0-9_]*__/g; // Same detection rule as the ExportOptions.plist template and the IOS-TESTFLIGHT validation
 const EXPORT_OPTIONS_REL = STORE_APP_FILES.ios.find((rel) => rel.endsWith("ExportOptions.plist"));
 
-// Flutter 스토어 배포 진단 — 선택한 플랫폼의 필수 파일과 ExportOptions.plist 플레이스홀더.
-// 스토어 시크릿 등록 여부는 이번 범위 밖이다. 반환: doctor 결과 행 배열.
+// Flutter store deploy diagnostics: required files for the selected platforms and ExportOptions.plist placeholders.
+// Whether store secrets are registered is out of scope. Returns an array of doctor result rows.
 export function flutterStoreChecks(cwd, existing, { docs }) {
   const saved = existing.options.flutterStore == null ? null : parseStoreList(existing.options.flutterStore);
-  // 저장값 없는 기존 설치는 설치된 스토어 워크플로우로 추론한다 (interactive와 같은 규칙).
+  // An existing install with no saved value is inferred from the installed store workflows (same rule as interactive).
   const stores = saved ?? inferInstalledStores(join(cwd, PATHS.workflowsDir));
   const flutterRoot = existing.paths.get("flutter") || ".";
   const rows = [];
@@ -21,29 +22,29 @@ export function flutterStoreChecks(cwd, existing, { docs }) {
   for (const platform of STORE_PLATFORMS.filter((p) => stores.includes(p))) {
     const files = storeAppFilesFor([platform]).map((rel) => posix.join(flutterRoot, rel));
     const missing = files.filter((file) => !existsSync(join(cwd, file)));
-    const head = { name: PLATFORM_ROW_NAME[platform], purpose: "fastlane 스토어 업로드에 필요한 파일" };
+    const head = { name: t(PLATFORM_ROW_NAME[platform]), purpose: t("core.flutterDoctor.purpose.storeFiles") };
     rows.push(missing.length
       ? {
-        ...head, status: "WARN", value: `없는 파일: ${missing.join(", ")}`,
-        impact: ["이 파일이 없으면 스토어 배포 워크플로우가 fastlane 단계에서 실패합니다."],
-        actions: ["마법사를 다시 실행하면 없는 파일만 새로 만들어 줍니다 (이미 있는 파일은 덮어쓰지 않음)"],
+        ...head, status: "WARN", value: t("core.flutterDoctor.value.missing", { files: missing.join(", ") }),
+        impact: [t("core.flutterDoctor.impact.missing")],
+        actions: [t("core.flutterDoctor.action.missing")],
         doc: docs.flutterStore,
       }
-      : { ...head, status: "OK", value: `${files.length}개 있음` });
+      : { ...head, status: "OK", value: t("core.flutterDoctor.value.present", { count: files.length }) });
   }
 
   const plistPath = posix.join(flutterRoot, EXPORT_OPTIONS_REL);
   if (stores.includes("ios") && existsSync(join(cwd, plistPath))) {
-    const head = { name: "ExportOptions.plist", purpose: "iOS 서명·내보내기 설정" };
+    const head = { name: "ExportOptions.plist", purpose: t("core.flutterDoctor.purpose.exportOptions") };
     const left = [...new Set(readFileSync(join(cwd, plistPath), "utf8").match(PLACEHOLDER_RE) ?? [])];
     rows.push(left.length
       ? {
-        ...head, status: "WARN", value: `채워지지 않은 값: ${left.join(", ")}`,
-        impact: ["채우지 않으면 IOS-TESTFLIGHT 워크플로우가 ExportOptions.plist 검증 단계에서 중단됩니다."],
-        actions: [`${plistPath} 의 플레이스홀더를 실제 값(Team ID · 번들 ID · 프로비저닝 프로파일 이름)으로 바꾸세요`],
+        ...head, status: "WARN", value: t("core.flutterDoctor.value.unfilled", { left: left.join(", ") }),
+        impact: [t("core.flutterDoctor.impact.unfilled")],
+        actions: [t("core.flutterDoctor.action.unfilled", { path: plistPath })],
         doc: docs.flutterStore,
       }
-      : { ...head, status: "OK", value: "플레이스홀더 없음" });
+      : { ...head, status: "OK", value: t("core.flutterDoctor.value.noPlaceholder") });
   }
   return rows;
 }

package/src/core/flutter-hooks.js

@@ -1,5 +1,5 @@
-// Flutter 타입 훅 — types.js 레지스트리의 flutter 항목이 가리키는 구현 모음.
-// 공통 코드는 flutter를 직접 알지 못하고 훅 이름으로만 호출한다(각 훅의 계약은 types.js 머리말 참고).
+// Flutter type hooks: the implementations the flutter entry of the types.js registry points to.
+// Common code does not know flutter directly and calls it only by hook name (see the types.js header for each hook's contract).
 import { existsSync } from "node:fs";
 import {
   ENV_MODES, DEPLOY_MODES, DEFAULT_ENV_MODE, DEFAULT_DEPLOY_MODE, STORE_PLATFORMS, NO_STORE,
@@ -11,20 +11,21 @@ import { flutterStoreChecks } from "./flutter-doctor.js";
 import { inferInstalledStores } from "./installed-stores.js";
 import { escapeYamlDoubleQuoted } from "./wizard-env.js";
 import { CliError } from "./errors.js";
+import { t } from "../i18n/index.js";
 
-// 저장값이 없으면 그 상태에서 실제로 적용되는 동작을 함께 알린다.
+// When there is no saved value, also states the behavior that actually applies in that state.
 function statusLabels(options) {
   return [
-    ` env_mode=${options.envMode ?? "미설정(dotenv 유지)"}`,
-    ` flutter_store=${options.flutterStore ?? "미설정(둘 다 설치)"}`,
-    ` android_deploy_mode=${options.androidDeployMode ?? "미설정(store_only)"}`,
-    ` ios_deploy_mode=${options.iosDeployMode ?? "미설정(store_only)"}`,
+    ` env_mode=${options.envMode ?? t("core.flutterHooks.status.envModeUnset")}`,
+    ` flutter_store=${options.flutterStore ?? t("core.flutterHooks.status.storeUnset")}`,
+    ` android_deploy_mode=${options.androidDeployMode ?? t("core.flutterHooks.status.deployModeUnset")}`,
+    ` ios_deploy_mode=${options.iosDeployMode ?? t("core.flutterHooks.status.deployModeUnset")}`,
   ].join("");
 }
 
-// 스토어 저장값이 없는 기존 Flutter 설치는 설치돼 있는 스토어 워크플로우로 추론한다(대화형과 같은 결론).
-// 추론하지 않으면 미결정이 "둘 다"로 확정 저장되어, 지웠던 플랫폼의 워크플로우·fastlane 파일이 되살아난다.
-// workflowsDir가 없으면(status 등 읽기 전용 경로) 추론하지 않는다.
+// An existing Flutter install with no saved store value is inferred from the installed store workflows (same conclusion as interactive).
+// Without inference the undecided state would be saved as "both", resurrecting workflows and fastlane files of a platform that was removed.
+// Without workflowsDir (read-only paths such as status) no inference is made.
 function resolveOptions({ opts = {}, existing = null, workflowsDir = null }) {
   const inferredStores = workflowsDir && opts.flutterStore == null && existing?.types?.includes("flutter")
     && existing.options?.flutterStore == null && existsSync(workflowsDir)
@@ -38,35 +39,35 @@ function resolveOptions({ opts = {}, existing = null, workflowsDir = null }) {
   });
 }
 
-// version.yml options 아래 Flutter 블록(6칸 들여쓰기). 값이 비었으면 워크플로우 템플릿 기본값과 같은 값으로 채운다 —
-// 저장값과 실제 설치 내용이 어긋나지 않게. stores가 null(미결정)이면 현행 동작대로 둘 다 설치되므로 "android,ios"로 기록한다.
+// Flutter block under version.yml options (6-space indent). Empty values are filled with the same values as the workflow template defaults,
+// so the saved values do not diverge from what was actually installed. When stores is null (undecided) both are installed as today, so "android,ios" is recorded.
 function versionOptionsBlock({ envMode, stores, androidDeployMode, iosDeployMode } = {}) {
   const quote = (v) => `"${escapeYamlDoubleQuoted(v)}"`;
   return [
-    `      env_mode: ${quote(envMode || DEFAULT_ENV_MODE)} # ${ENV_MODES.join(" | ")} (Flutter 환경변수 주입 방식)`,
-    `      flutter_store: ${quote(formatStoreList(stores ?? STORE_PLATFORMS))} # android | ios | android,ios | none (스토어 배포 대상)`,
-    `      android_deploy_mode: ${quote(androidDeployMode || DEFAULT_DEPLOY_MODE)} # ${DEPLOY_MODES.join(" | ")} (Play Store 배포 모드)`,
-    `      ios_deploy_mode: ${quote(iosDeployMode || DEFAULT_DEPLOY_MODE)} # ${DEPLOY_MODES.join(" | ")} (iOS 배포 모드)`,
+    `      env_mode: ${quote(envMode || DEFAULT_ENV_MODE)} # ${ENV_MODES.join(" | ")} ${t("core.flutterHooks.comment.envMode")}`,
+    `      flutter_store: ${quote(formatStoreList(stores ?? STORE_PLATFORMS))} # android | ios | android,ios | none ${t("core.flutterHooks.comment.store")}`,
+    `      android_deploy_mode: ${quote(androidDeployMode || DEFAULT_DEPLOY_MODE)} # ${DEPLOY_MODES.join(" | ")} ${t("core.flutterHooks.comment.androidDeployMode")}`,
+    `      ios_deploy_mode: ${quote(iosDeployMode || DEFAULT_DEPLOY_MODE)} # ${DEPLOY_MODES.join(" | ")} ${t("core.flutterHooks.comment.iosDeployMode")}`,
   ].join("\n");
 }
 
-// 값 목록 검증 플래그 하나를 만든다 — 값이 목록 밖이면 CliError.
+// Builds one flag validated against a value list; CliError when the value is outside the list.
 const enumFlag = (flag, field, isValid, allowed) => ({
   flag, field, initial: "",
   parse(v) {
-    if (!isValid(v)) throw new CliError(`${flag} 값이 올바르지 않습니다: ${v ?? "(없음)"} (${allowed.join(" | ")})`);
+    if (!isValid(v)) throw new CliError(t("core.flutterHooks.err.invalidFlag", { flag, value: v ?? t("core.flutterHooks.noValue"), allowed: allowed.join(" | ") }));
     return v;
   },
 });
 
 export const flutterHooks = {
   resolveOptions,
-  // 확정된 옵션 → 설치 컨텍스트 필드. 기본값은 옵션이 없을 때의 "미결정" 상태다.
+  // Decided options to install-context fields. The defaults are the "undecided" state used when there are no options.
   contextDefaults: {
-    envMode: "",             // "dart-define" | "dotenv". ""=미결정 → 템플릿 기본값(dart-define)
-    flutterStore: null,      // 스토어 배포 대상 string[] (예: ["android","ios"]). null=미결정 → 둘 다(현행 동작)
-    androidDeployMode: "",   // store_only | store_prepare | store_submit. ""=미결정 → store_only
-    iosDeployMode: "",       // 위와 동일 (iOS)
+    envMode: "",             // "dart-define" | "dotenv". ""=undecided, template default (dart-define) applies
+    flutterStore: null,      // store deploy targets, string[] (e.g. ["android","ios"]). null=undecided, both (current behavior)
+    androidDeployMode: "",   // store_only | store_prepare | store_submit. ""=undecided, store_only
+    iosDeployMode: "",       // same as above (iOS)
   },
   contextFields: (options) => ({
     envMode: options.envMode,
@@ -78,21 +79,21 @@ export const flutterHooks = {
     envMode, stores: flutterStore, androidDeployMode, iosDeployMode,
   }),
   versionOptionsBlock,
-  // version.yml 저장 키 → 파싱 결과 필드. 값은 원문 문자열로 돌려주고, 유효성 판정은 resolveOptions 몫이다.
+  // Saved version.yml key to parsed-result field. The value is returned as the raw string; validity is resolveOptions' job.
   savedOptionKeys: {
     env_mode: "envMode", flutter_store: "flutterStore",
     android_deploy_mode: "androidDeployMode", ios_deploy_mode: "iosDeployMode",
   },
-  // CLI 플래그 — 파싱 결과 필드(opts)와 값 검증. initial은 미지정 값이다.
+  // CLI flags: parsed-result field (opts) and value validation. initial is the not-given value.
   cliFlags: [
     enumFlag("--flutter-env-mode", "flutterEnvMode", isEnvMode, ENV_MODES),
     {
       flag: "--flutter-store", field: "flutterStore", initial: null,
       parse(v) {
-        // 빈 문자열은 parseStoreList가 []로 보지만, 스토어를 안 고르겠다는 뜻은 명시적인 none으로만 받는다.
+        // parseStoreList sees an empty string as [], but "select no store" is accepted only as an explicit none.
         const stores = v ? parseStoreList(v) : null;
         if (stores === null) {
-          throw new CliError(`--flutter-store 값이 올바르지 않습니다: ${v || "(없음)"} (${[STORE_PLATFORMS.join(","), ...STORE_PLATFORMS, NO_STORE].join(" | ")})`);
+          throw new CliError(t("core.flutterHooks.err.invalidFlag", { flag: "--flutter-store", value: v || t("core.flutterHooks.noValue"), allowed: [STORE_PLATFORMS.join(","), ...STORE_PLATFORMS, NO_STORE].join(" | ") }));
         }
         return stores;
       },
@@ -100,20 +101,20 @@ export const flutterHooks = {
     enumFlag("--android-deploy-mode", "androidDeployMode", isDeployMode, DEPLOY_MODES),
     enumFlag("--ios-deploy-mode", "iosDeployMode", isDeployMode, DEPLOY_MODES),
   ],
-  // 설치 직후 알릴 경고 — store_submit은 main push마다 심사를 자동 제출하므로 선택하지 않은 스토어에는 뜨면 안 된다.
+  // Warnings shown right after install: store_submit auto-submits a review on every main push, so it must not appear for a store that was not selected.
   installNotices: ({ stores, androidDeployMode, iosDeployMode }) => [
     (stores === null || stores.includes("android")) && deployModeWarning(androidDeployMode),
     (stores === null || stores.includes("ios")) && deployModeWarning(iosDeployMode),
   ],
-  // 설치 로그에 남길 선택값 [이름, 값] 목록
+  // Selected values to record in the install log, as [name, value] pairs
   logChoices: (context) => {
-    const stores = Array.isArray(context.flutterStore) ? (context.flutterStore.join(",") || "없음") : "미결정(둘 다)";
+    const stores = Array.isArray(context.flutterStore) ? (context.flutterStore.join(",") || t("core.flutterHooks.log.storesNone")) : t("core.flutterHooks.log.storesUndecided");
     return [["flutter",
       `env=${context.envMode || "-"} stores=${stores} android=${context.androidDeployMode || "-"} ios=${context.iosDeployMode || "-"}`]];
   },
-  // 스토어 대상이 배열일 때만 스토어 워크플로우 필터를 건다(null=미결정 → 전부 설치).
+  // The store workflow filter applies only when the store target is an array (null=undecided, install everything).
   workflowFilter: ({ flutterStore }) => (Array.isArray(flutterStore) ? storeWorkflowFilter(flutterStore) : null),
-  // 선택 해제된 스토어 워크플로우 정리 — 대상이 미결정(null)이면 아무것도 지우지 않는다.
+  // Cleans up deselected store workflows; when the target is undecided (null) nothing is deleted.
   cleanupWorkflows: (workflowsDir, installed, context, baseline, opts) => (Array.isArray(context.flutterStore)
     ? cleanupDeselectedStoreWorkflows(workflowsDir, installed, context.flutterStore, baseline, opts)
     : { removed: [], backedUp: [] }),