project-auto-wizard 0.13.2 → 0.14.0

package/payload/scripts/truncate_release_notes.py

@@ -31,6 +31,8 @@ Contract:
 import argparse
 import sys
 
+from messages import t, use_utf8_output
+
 
 def log(message):
     print(message, file=sys.stderr)
@@ -47,19 +49,19 @@ def run(path, limit, mode):
         with open(path, "r", encoding="utf-8", newline="", errors="replace") as f:
             text = f.read()
     except FileNotFoundError:
-        log(f"릴리즈 노트 파일 없음, 건너뜀: {path}")
+        log(t("truncate.file_missing", path=path))
         return 0
 
     length = len(text) if mode == "char" else len(text.encode("utf-8"))
     if length <= limit:
-        log(f"한도 이내 ({length}/{limit} {mode}), 자르지 않음: {path}")
+        log(t("truncate.within_limit", length=length, limit=limit, mode=mode, path=path))
         return 0
 
     truncated = truncate_text(text, limit, mode)
     with open(path, "w", encoding="utf-8", newline="") as f:
         f.write(truncated)
 
-    log(f"한도 초과 ({length} -> {limit} {mode} 이하로 절단): {path}")
+    log(t("truncate.truncated", length=length, limit=limit, mode=mode, path=path))
     return 0
 
 
@@ -72,14 +74,13 @@ def build_parser():
 
 
 def main(argv=None):
-    sys.stdout.reconfigure(errors="replace")
-    sys.stderr.reconfigure(errors="replace")
+    use_utf8_output()
 
     parser = build_parser()
     args = parser.parse_args(argv)
 
     if args.limit <= 0:
-        log(f"ERROR: limit은 양수여야 함: {args.limit}")
+        log(t("truncate.limit_positive", limit=args.limit))
         return 1
 
     return run(args.file, args.limit, args.mode)

package/payload/scripts/version_manager.py

@@ -38,26 +38,28 @@ import sys
 from pathlib import Path
 from typing import Callable, NamedTuple
 
+from messages import t, use_utf8_output
+
 VERSION_YML = "version.yml"
 
 
 class VersionSyncError(Exception):
-    """version.yml·프로젝트 파일에 버전을 쓰지 못했다 — exit 1로 알린다."""
+    """The version could not be written to version.yml or a project file — reported via exit 1."""
 SEMVER_RE = re.compile(r"^\d+\.\d+\.\d+$")
 
-# 프로젝트 파일 버전 해석 규칙 — 설치 시 감지(src/core/detect.js coreVersion)와 같아야 한다.
-# version.yml은 x.y.z만 저장·증가시키므로 파일의 1.2.3-rc.1·1.2.3+4·1.2.0-SNAPSHOT은 코어 x.y.z로 읽는다.
-# 다르게 읽으면 설치 직후 version.yml 값과 첫 릴리스 때 읽은 값이 어긋난다.
+# How project-file versions are interpreted — must match the install-time detection (src/core/detect.js coreVersion).
+# version.yml only stores and bumps x.y.z, so 1.2.3-rc.1, 1.2.3+4 and 1.2.0-SNAPSHOT in a file are read as the core x.y.z.
+# Reading them differently would make the value right after install disagree with the one read at the first release.
 _CORE_VERSION_RE = re.compile(r"^v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.+-]*)?$")
 
-# Gradle·Maven의 -SNAPSHOT은 특정 버전의 프리릴리스가 아니라 "개발 중 빌드" 표식이다(배포 저장소 선택,
-# 산출물 이름에 쓰인다). 그래서 버전을 올려도 떼지 않고 새 버전 뒤에 그대로 붙인다.
-# rc.1·beta.1 같은 프리릴리스는 그 버전 전용 표식이라 새 x.y.z로 릴리스할 때 버린다.
+# Gradle/Maven -SNAPSHOT is not a pre-release of a specific version but an "in-development build" marker (it selects the
+# publishing repository and appears in artifact names). So it is kept and re-appended after a version bump.
+# Pre-releases such as rc.1 or beta.1 belong to that version only, so they are dropped when releasing a new x.y.z.
 SNAPSHOT_SUFFIX = "-SNAPSHOT"
 
 
 def core_version(value):
-    """x.y.z[-pre][+build] → x.y.z. 버전 형식이 아니면 None."""
+    """x.y.z[-pre][+build] -> x.y.z. None if the value is not a version."""
     m = _CORE_VERSION_RE.match(str(value or "").strip())
     return m.group(1) if m else None
 
@@ -287,7 +289,7 @@ def increment_patch(version):
 
 
 def increment_version(version, bump="patch"):
-    """bump: 'major'|'minor'|'patch'. 생략하면 기존과 동일하게 patch(increment_patch)로 동작."""
+    """bump: 'major'|'minor'|'patch'. Defaults to patch when omitted."""
     if bump == "major":
         major, _minor, _patch = version.split(".")
         return f"{int(major) + 1}.0.0"
@@ -315,7 +317,7 @@ def get_higher_version(v1, v2):
 
 def update_version_yml(new_version):
     if not write_scalar_key("version", new_version):
-        # 키가 없으면 아무것도 쓰지 않은 채 성공처럼 끝나 매번 같은 버전이 나왔다.
+        # Without the key nothing was written yet the call looked successful, so the same version came out every time.
         log("WARNING: version field missing in version.yml, adding it")
         text = read_text()
         line = f'version: "{new_version}"\n'
@@ -365,16 +367,16 @@ _XML_TOKEN_RE = re.compile(
 
 
 def _pom_text_span(text, path):
-    """루트(<project>) 기준 경로의 요소 텍스트 구간 (start, end). 없으면 None.
-    <parent>·<dependencies> 안의 <version>은 다른 아티팩트 버전이라 깊이로 구분한다."""
+    """Text span (start, end) of the element at `path` under the root (<project>). None if absent.
+    A <version> inside <parent>/<dependencies> is another artifact's version, so depth tells them apart."""
     stack = []
     start = None
     target = list(path)
     for m in _XML_TOKEN_RE.finditer(text):
         name = m.group(2)
         if not name:
-            continue  # 주석·CDATA·선언
-        if m.group(1):  # 닫는 태그
+            continue  # comment / CDATA / declaration
+        if m.group(1):  # closing tag
             if start is not None and stack[1:] == target:
                 return start, m.start()
             if stack:
@@ -401,8 +403,8 @@ def _pom_replace(text, path, value):
 
 
 def sync_maven(path_dir, new_version):
-    """pom.xml의 프로젝트 자신의 <version>만 바꾼다. 하위 모듈은 루트를 가리키는
-    <parent><version>(과 루트와 같던 자기 <version>)만 따라 올린다."""
+    """Only change the project's own <version> in pom.xml. A child module follows only the
+    <parent><version> that points at the root (and its own <version> if it equaled the root's)."""
     root_pom = Path(path_dir) / "pom.xml"
     if not root_pom.is_file():
         return False
@@ -412,7 +414,7 @@ def sync_maven(path_dir, new_version):
         log(f"WARNING: spring: {root_pom} has no project <version> (inherited from parent?) — skipping")
         return True
     if "${" in old_version:
-        # ${revision} 같은 CI-friendly 버전은 프로퍼티 쪽에서 관리하므로 건드리지 않는다.
+        # CI-friendly versions such as ${revision} are managed in a property, so leave them alone.
         log(f"WARNING: spring: {root_pom} <version> is a property ({old_version}) — skipping")
         return True
     new_full = _keep_snapshot(old_version, new_version)
@@ -440,12 +442,12 @@ _GRADLE_SHARED_BLOCKS = ("allprojects", "subprojects")
 
 
 def _gradle_code(line, quote=""):
-    """한 줄에서 주석을 떼고 따옴표 안 글자는 공백으로 바꾼다. url 'https://…'의 `//`나
-    문자열 속 중괄호가 블록 깊이 계산을 흐트러뜨리지 않게 한다. detect.js와 같은 규칙.
+    """Strip the comment from a line and blank out quoted text, so the `//` in a url 'https://...' or
+    a brace inside a string cannot disturb block-depth counting. Same rule as detect.js.
 
-    quote는 이 줄이 시작될 때 열려 있던 따옴표다. 삼중따옴표(\"\"\" ''')는 여러 줄에 걸치므로
-    (코드, 줄 끝에서 열려 있는 따옴표)를 돌려줘 다음 줄이 이어받게 한다. 한 줄짜리 따옴표는
-    줄 끝에서 닫힌 것으로 본다."""
+    `quote` is the quote that was open when this line started. Triple quotes (\"\"\" ''') span lines, so
+    return (code, quote still open at end of line) for the next line to continue. A single-line quote
+    is treated as closed at end of line."""
     out, i = [], 0
     while i < len(line):
         ch = line[i]
@@ -468,14 +470,14 @@ def _gradle_code(line, quote=""):
 
 
 def _gradle_version_matches(text):
-    """프로젝트 버전 줄의 match 목록. 읽기와 동기화가 이 한 곳을 공유해 같은 줄만 다룬다.
+    """Matches of the project version lines. Reading and syncing share this one place so they touch the same lines.
 
-    들여쓰지 않은 `version =`이 있으면 그것만 쓴다. 없을 때만 allprojects/subprojects 블록 안의
-    들여쓴 줄을 인정한다 — `node { version = '20.11.0' }` 같은 플러그인 설정 블록을
-    프로젝트 버전으로 오인하면 버전이 뛰고 빌드 설정이 깨진다."""
+    If an unindented `version =` exists, only that is used. Only when there is none are indented lines
+    inside allprojects/subprojects blocks accepted — mistaking a plugin config block such as `node { version = '20.11.0' }`
+    for the project version would make the version jump and break the build config."""
     top, shared = [], []
-    stack = []  # 열린 블록 이름. 줄 끝이 `{`로 끝나는 줄의 마지막 단어
-    quote = ""  # 여러 줄 문자열 안이면 그 따옴표. 문자열 속 줄은 코드가 아니다
+    stack = []  # open block names: the last word of each line ending in `{`
+    quote = ""  # the open quote while inside a multi-line string; lines inside a string are not code
     pos = 0
     for line in text.splitlines(keepends=True):
         m = None if quote else _GRADLE_VERSION_RE.match(line)
@@ -511,11 +513,11 @@ def sync_spring(path_dir, new_version):
         return
     for gradle_file in candidates:
         text = read_file(gradle_file)
-        # 줄 시작의 `version =`만 프로젝트 버전이다. 앵커가 없으면 kotlin_version 같은
-        # 의존성 버전 변수까지 함께 바뀌어 빌드가 깨진다.
+        # Only a `version =` at the start of a line is the project version. Without the anchor,
+        # dependency version variables such as kotlin_version would change too and break the build.
         matches = _gradle_version_matches(text)
         new_text = text
-        # 뒤에서부터 바꿔 앞쪽 span이 밀리지 않게 한다.
+        # Replace from the end so earlier spans do not shift.
         for m in reversed(matches):
             replaced = f"{m.group(1)}{m.group(2)}{_keep_snapshot(m.group(3), new_version)}{m.group(2)}"
             new_text = new_text[:m.start()] + replaced + new_text[m.end():]
@@ -527,7 +529,7 @@ def sync_spring(path_dir, new_version):
 
 
 def _pubspec_build_number(path_dir):
-    """pubspec.yaml `version: x.y.z+N`의 N. 없으면 None."""
+    """N in pubspec.yaml `version: x.y.z+N`. None if absent."""
     target = Path(path_dir) / "pubspec.yaml"
     if not target.is_file():
         return None
@@ -536,9 +538,9 @@ def _pubspec_build_number(path_dir):
 
 
 def get_reconciled_version_code():
-    """version.yml의 version_code와 pubspec.yaml의 +N 중 큰 값.
-    로컬 수동 배포 등으로 pubspec 쪽이 앞서 있으면 스토어는 더 작은 build number를
-    거부하므로, 그 값을 version.yml에 반영해 역행을 막는다."""
+    """The larger of version.yml version_code and the +N in pubspec.yaml.
+    If pubspec is ahead (e.g. after a manual local release), the store rejects a lower build number,
+    so that value is adopted into version.yml to prevent a regression."""
     code = int(get_version_code())
     types = get_project_types_csv()
     pubspec_codes = [
@@ -586,7 +588,7 @@ def sync_json_version(target, new_version, key_path):
     try:
         data = json.loads(raw)
     except json.JSONDecodeError as e:
-        # 건너뛰고 성공으로 끝내면 태그·version.yml과 패키지 버전이 조용히 어긋난다.
+        # Skipping and reporting success would silently leave the tag/version.yml and the package version out of step.
         raise VersionSyncError(f"{target} is not valid JSON ({e}) — cannot write version")
     node = data
     for k in key_path[:-1]:
@@ -601,8 +603,8 @@ _TOML_VERSION_RE = re.compile(r'^[ \t]*version[ \t]*=[ \t]*([\'"])([^\'"\n]*)\1'
 
 
 def _pyproject_version_span(text):
-    """[project] 또는 [tool.poetry] 섹션의 version 값 구간. [tool.*] 등 다른 섹션의
-    `version =`은 도구 설정이라 패키지 버전으로 쓰지 않는다."""
+    """Value span of `version` in the [project] or [tool.poetry] section. A `version =` in other sections
+    such as [tool.*] is tool config, not the package version."""
     headers = list(_TOML_HEADER_RE.finditer(text))
     for i, h in enumerate(headers):
         if h.group(1) not in ("project", "tool.poetry"):
@@ -614,13 +616,13 @@ def _pyproject_version_span(text):
     return None
 
 
-# setup(version="x.y.z"). python_requires·python_version 같은 다른 키는 앞 글자로 거른다.
+# setup(version="x.y.z"). Other keys such as python_requires / python_version are filtered out by the preceding character.
 _SETUP_PY_VERSION_RE = re.compile(r"""(?<![\w.])version\s*=\s*(['"])([^'"]+)\1""")
 
 
 def _python_version_spans(path_dir):
-    """버전을 읽고 쓰는 파일과 값 구간 목록. 읽을 때는 앞쪽(pyproject.toml → setup.py)이 우선이다.
-    setup.py만 쓰는 프로젝트도 설치 때 버전을 읽으므로, 릴리스 때도 같은 파일을 읽고 써야 한다."""
+    """Files and value spans for reading/writing the version. When reading, earlier entries win (pyproject.toml -> setup.py).
+    Projects using only setup.py also have their version read at install time, so releases must read and write the same file."""
     spans = []
     pyproject = Path(path_dir) / "pyproject.toml"
     if pyproject.is_file():
@@ -638,7 +640,7 @@ def _python_version_spans(path_dir):
 def sync_python(path_dir, new_version):
     spans = _python_version_spans(path_dir)
     if not spans:
-        # dynamic = ["version"] 등 버전을 파일에 두지 않는 구성은 쓸 곳이 없다.
+        # Setups that keep the version out of the file (e.g. dynamic = ["version"]) have nowhere to write it.
         log(f"WARNING: python: no version in pyproject.toml [project]/[tool.poetry] or setup.py under {path_dir} — skipping")
         return
     for target, (start, end) in spans:
@@ -651,8 +653,8 @@ _PLIST_VERSION_RE = re.compile(r'(<key>CFBundleShortVersionString</key>\s*<strin
 
 
 def _rn_app_plists(ios_dir):
-    """앱 타깃의 Info.plist만 이름순으로. Pods·빌드 산출물·테스트 타깃은 우리 버전이 아니다.
-    읽기와 동기화가 같은 파일 집합을 보도록 한 곳에서 고른다."""
+    """Only the app target Info.plist files, sorted by name. Pods, build output and test targets do not carry our version.
+    Chosen in one place so reading and syncing see the same set of files."""
     skip = {"Pods", "build"}
     return [
         p for p in sorted(ios_dir.glob("*/Info.plist"))
@@ -669,7 +671,7 @@ def sync_react_native(path_dir, new_version):
             m = _PLIST_VERSION_RE.search(text)
             if not m:
                 continue
-            # $(MARKETING_VERSION) 같은 빌드 변수 참조는 Xcode 설정이 원본이라 덮어쓰지 않는다.
+            # A build-variable reference such as $(MARKETING_VERSION) is owned by the Xcode settings, so do not overwrite it.
             if m.group(2).strip().startswith("$("):
                 log(f"skipped: {plist_file} — CFBundleShortVersionString references a build variable")
                 continue
@@ -710,7 +712,7 @@ def sync_all_project_files(new_version):
         raise SystemExit("ERROR: version.yml has no readable project_types — cannot sync project files")
     errors = []
     for t in types:
-        # 한 타입이 실패해도 나머지는 맞춰 두고, 실패는 끝에서 모아 종료 코드로 알린다.
+        # Keep syncing the other types when one fails; collect failures and report them via the exit code at the end.
         try:
             sync_for_type(t, new_version, get_reconciled_version_code)
         except VersionSyncError as e:
@@ -725,11 +727,11 @@ README_VERSION_LINE_RE = re.compile(
 
 
 def update_readme_version(new_version, path="README.md"):
-    """AUTO-VERSION-SECTION 마커 바로 아래 버전 줄만 새 버전으로 바꾼다.
+    """Rewrite only the version line right below the AUTO-VERSION-SECTION marker.
 
-    README 갱신 워크플로우는 태그를 만든 뒤에 돌기 때문에, 버전 확정 커밋에 README가 함께
-    들어가지 않으면 태그 시점 README가 한 버전 전을 가리킨다. 마커·줄 삽입 같은 나머지 일은
-    그 워크플로우에 맡기고, 여기서는 이미 있는 줄만 고친다(날짜 표기 여부도 그대로 둔다)."""
+    The README update workflow runs after the tag is created, so unless the README is part of the
+    version-confirm commit, the README at the tag points one version behind. Everything else, such as
+    inserting the marker or line, is left to that workflow; here only an existing line is fixed (date presence is kept)."""
     p = Path(path)
     if not p.is_file():
         return False
@@ -763,7 +765,7 @@ def update_all_versions(new_version):
 # ===================================================================
 
 def _read_spring(path_dir):
-    # build.gradle에 버전이 없으면(allprojects 설정만 있는 경우 등) build.gradle.kts → pom.xml 순으로 이어 본다.
+    # If build.gradle has no version (e.g. only an allprojects config), try build.gradle.kts, then pom.xml.
     for name in ("build.gradle", "build.gradle.kts"):
         p = Path(path_dir) / name
         if p.is_file():
@@ -796,9 +798,9 @@ def _read_package_json(path_dir):
 
 
 def _read_react_native(path_dir):
-    """릴리스 때 쓰는 파일(ios/<앱>/Info.plist, android/app/build.gradle)에서 읽는다.
-    package.json version은 동기화하지 않으므로 기준으로 삼으면 매 릴리스마다 어긋난다.
-    $(MARKETING_VERSION) 참조나 템플릿 기본값 "1.0"처럼 x.y.z가 아닌 값은 건너뛴다."""
+    """Read from the files used at release time (ios/<app>/Info.plist, android/app/build.gradle).
+    package.json version is not synced, so using it as the reference would drift on every release.
+    Values that are not x.y.z, such as a $(MARKETING_VERSION) reference or the template default "1.0", are skipped."""
     ios_dir = Path(path_dir) / "ios"
     if ios_dir.is_dir():
         for plist in _rn_app_plists(ios_dir):
@@ -839,8 +841,8 @@ def _sync_none(path_dir, new_version, version_code_getter):
 
 
 class TypeHandler(NamedTuple):
-    """타입별 버전 파일 처리. read(path_dir)는 파일의 버전(없으면 None),
-    sync(path_dir, new_version, version_code_getter)는 새 버전을 파일에 쓴다."""
+    """Per-type version file handling. read(path_dir) returns the version in the file (None if absent),
+    sync(path_dir, new_version, version_code_getter) writes the new version to the file."""
     read: Callable
     sync: Callable
 
@@ -850,11 +852,11 @@ _PACKAGE_JSON = TypeHandler(
     sync=lambda d, v, _code: sync_json_version(Path(d) / "package.json", v, ["version"]),
 )
 
-# 새 타입은 여기 한 줄만 추가하면 읽기(sync 비교)와 쓰기가 함께 따라온다.
-# 버전 파일이 없는 타입(basic·go)은 version.yml만 쓰도록 빈 핸들러를 둔다.
+# Adding one line here is enough for a new type: both reading (sync comparison) and writing follow.
+# Types without a version file (basic, go) get an empty handler so only version.yml is written.
 TYPE_HANDLERS = {
     "spring": TypeHandler(read=_read_spring, sync=lambda d, v, _code: sync_spring(d, v)),
-    # build number가 필요한 타입만 version_code를 계산한다 (pubspec 조정 부수효과가 있다).
+    # Only types that need a build number compute version_code (this has a pubspec-adjusting side effect).
     "flutter": TypeHandler(read=_read_flutter, sync=lambda d, v, code: sync_flutter(d, v, code())),
     "react": _PACKAGE_JSON,
     "next": _PACKAGE_JSON,
@@ -954,7 +956,7 @@ def cmd_increment(args):
         return 1
     bump = getattr(args, "bump", None) or "patch"
     new_version = increment_version(current_version, bump)
-    # build number를 먼저 올려야 이어지는 pubspec 동기화에 새 값이 함께 기록된다.
+    # Bump the build number first so the following pubspec sync writes the new value too.
     set_version_code(get_reconciled_version_code() + 1)
     update_all_versions(new_version)
 
@@ -988,7 +990,7 @@ def build_parser():
     sub.add_parser("get-code")
     p_increment = sub.add_parser("increment")
     p_increment.add_argument("--bump", choices=["major", "minor", "patch"], default="patch",
-                              help="승격 폭 (기본 patch — 지정 안 하면 기존 동작과 동일)")
+                              help=t("version.bump_help"))
     sub.add_parser("increment-code")
     sub.add_parser("sync")
 
@@ -999,6 +1001,7 @@ def build_parser():
 
 
 def main(argv=None):
+    use_utf8_output()
     parser = build_parser()
     args = parser.parse_args(argv)
 

package/payload/version.yml.template

@@ -34,6 +34,7 @@
 version: "{{VERSION}}"
 version_code: {{VERSION_CODE}} # app build number
 project_types: {{PROJECT_TYPES}} # first entry is primary
+language: "{{LANGUAGE}}" # message language: en | ko
 {{PROJECT_PATHS}}
 metadata:
   last_updated: "{{NOW}}"
@@ -52,6 +53,6 @@ metadata:
     options:
       semver_auto: {{OPT_SEMVER_AUTO}}
       copilot_ai: {{OPT_COPILOT_AI}}
-      deploy_style: "{{OPT_DEPLOY_STYLE}}" # simple | nginx | traefik | none (서버 배포 워크플로우)
+      deploy_style: "{{OPT_DEPLOY_STYLE}}" # simple | nginx | traefik | none (server deploy workflows)
 {{TYPE_OPTIONS}}
 {{DEPLOY}}

package/payload/workflows/common/PROJECT-COMMON-AI-PR-SUMMARY.yaml

@@ -78,8 +78,9 @@ jobs:
 
           git fetch origin {{MAIN_BRANCH}}
           git log --pretty=%s "origin/{{MAIN_BRANCH}}..HEAD" > commits.txt
-          # 본문 푸터 BREAKING CHANGE:는 제목 목록 뒤에 한 줄씩 덧붙인다 — 스크립트는 한 줄을
-          # 한 항목으로 읽으므로 본문 전체(%B)를 넣으면 설명 줄까지 변경 항목으로 잡힌다.
+          # Body-footer BREAKING CHANGE: lines are appended after the subject list, one per
+          # line. The script reads each line as one entry, so passing the whole body (%B)
+          # would turn description lines into change entries.
           git log --pretty=%b "origin/{{MAIN_BRANCH}}..HEAD" | grep -E '^BREAKING[ -]CHANGE[[:space:]]*:' >> commits.txt || true
           git diff --stat "origin/{{MAIN_BRANCH}}...HEAD" > _full_diff_stat.txt
           if [ "$(wc -l < _full_diff_stat.txt)" -gt 49 ]; then
@@ -89,10 +90,12 @@ jobs:
           fi
           rm -f _full_diff_stat.txt
 
-          # 헤더에는 이미 발행된 현재 버전이 아니라 이 PR이 병합되면 붙을 예상 버전을 보인다.
-          # 병합 뒤 버전을 올리는 쪽과 같은 규칙: trunk-based는 RELEASE-PUBLISH가 semver_auto면
-          # 커밋으로 승격 폭을 정하고, pr-flow에서 {{MAIN_BRANCH}}로 바로 들어가는 PR은
-          # VERSION-CONTROL 안전망이 patch를 올린다. 예상치라 AI 보조 판정 없이 규칙만 쓴다.
+          # The header shows the version this PR will get once merged, not the version
+          # that is already published. Same rules as whatever bumps the version after the
+          # merge: in trunk-based mode RELEASE-PUBLISH picks the bump size from the commits
+          # when semver_auto is on, and in pr-flow a PR going straight into {{MAIN_BRANCH}}
+          # gets a patch bump from the VERSION-CONTROL safety net. It is only an estimate,
+          # so rules alone are used, without any AI-assisted classification.
           CURRENT_VERSION=$(python3 .github/scripts/version_manager.py get 2>/dev/null | tail -n 1)
           MODE=$(python3 -c 'import re; t=open("version.yml",encoding="utf-8").read(); m=re.search(r"metadata:.*?template:.*?branches:.*?mode:\s*\"?([A-Za-z-]+)", t, re.S); print(m.group(1) if m else "pr-flow")' 2>/dev/null || echo "pr-flow")
           SEMVER_AUTO=$(python3 -c 'import re; t=open("version.yml",encoding="utf-8").read(); m=re.search(r"metadata:.*?template:.*?options:.*?semver_auto:\s*\"?(true|false)", t, re.S); print(m.group(1) if m else "false")' 2>/dev/null || echo "false")
@@ -111,12 +114,12 @@ jobs:
             --pr-title "$PR_TITLE" \
             --diff-stat-file diff_stat.txt | tail -n 1)
           ENGINE=$(python3 -c 'import json,sys; print(json.loads(sys.argv[1]).get("engine") or "unknown")' "$SUMMARY_RESULT" 2>/dev/null || echo "unknown")
-          # fallback이면 사유(스크립트가 ::warning::으로도 남김)를 engine 줄에 붙인다 — 잡 로그를 열지 않아도 원인이 보이게
+          # On fallback, append the reason (the script also emits it as ::warning::) to the engine line so the cause is visible without opening the job log
           FALLBACK_REASON=$(python3 -c 'import html,json,sys; print(html.escape((json.loads(sys.argv[1]).get("fallback_reason") or "")[:200]))' "$SUMMARY_RESULT" 2>/dev/null || echo "")
           ENGINE_LINE="$ENGINE${FALLBACK_REASON:+ ($FALLBACK_REASON)}"
           echo "engine: $ENGINE_LINE" >> "$GITHUB_STEP_SUMMARY"
 
-          # push마다 댓글이 쌓이지 않도록 이 봇이 남긴 요약 댓글을 표식으로 찾아 최신 내용으로 교체한다
+          # Find this bot's earlier summary comment by its marker and replace it with the latest content so pushes do not pile up comments
           MARKER="<!-- project-auto-wizard:pr-summary -->"
           {
             echo "$MARKER"
@@ -143,15 +146,17 @@ jobs:
         continue-on-error: true
         env:
           GITHUB_TOKEN: ${{ github.token }}
-          # 브랜치명을 run: 스크립트에 직접 ${{ }} 보간하지 않고 env로 전달한다 —
-          # git ref 이름은 $, 백틱, 세미콜론 등을 포함할 수 있어 직접 보간하면
-          # 셸 인젝션 경로가 된다(AUTO-CHANGELOG-CONTROL의 PR_TITLE과 동일한 이유).
+          # Pass the branch name through env instead of interpolating ${{ }} into the run:
+          # script - git ref names can contain $, backticks, semicolons and so on, so direct
+          # interpolation would be a shell-injection path (same reason as PR_TITLE in
+          # AUTO-CHANGELOG-CONTROL).
           HEAD_REF: ${{ github.event.pull_request.head.ref }}
         run: |
+          m() { python3 "$GITHUB_WORKSPACE/.github/scripts/messages.py" get "$@"; }
           ISSUE_NUM=$(python3 .github/scripts/issue_helper.py extract-branch-issue "$HEAD_REF")
 
           if [ -z "$ISSUE_NUM" ]; then
-            echo "브랜치명에서 이슈 번호를 찾지 못함 — 건너뜀: $HEAD_REF"
+            echo "$(m wf_aisum.no_issue_in_branch ref="$HEAD_REF")"
             exit 0
           fi