project-auto-wizard 0.12.2 → 0.13.0

package/payload/scripts/version_manager.py

@@ -5,13 +5,15 @@ version_manager.py — general-purpose version management script (stdlib only).
 This script is copied into user repos (.github/scripts/) by project-auto-wizard
 and runs standalone on GitHub Actions ubuntu runners (python3, no third-party deps).
 
-It is a Python rewrite of the battle-tested bash reference implementation
-(version_manager.sh). Behavioral equivalence with that script is the design goal:
+Design rules:
 - version.yml is the single source of truth for `version` and `version_code`.
 - version.yml is edited via line-based regex replacements that preserve all
   comments and formatting (never rewritten wholesale, never parsed with a YAML lib).
 - Versions are synced out to type-specific project files (build.gradle,
   pubspec.yaml, package.json, pyproject.toml, Info.plist, app.json, ...).
+- increment/set also rewrite the README.md version line under the
+  AUTO-VERSION-SECTION marker, so the release commit (and its tag) already
+  shows the new version.
 
 Usage:
     version_manager.py get              # current version (synced)
@@ -23,7 +25,8 @@ Usage:
 
 Contract:
     - The LAST line printed to stdout is always the value (callers do `| tail -n 1`).
-    - Exit 0 on success; exit 1 on validation failure or missing version.yml.
+    - Exit 0 on success; exit 1 on validation failure, missing version.yml,
+      or when a version could not be written (e.g. invalid package.json).
 """
 
 import argparse
@@ -33,10 +36,35 @@ import os
 import re
 import sys
 from pathlib import Path
+from typing import Callable, NamedTuple
 
 VERSION_YML = "version.yml"
+
+
+class VersionSyncError(Exception):
+    """version.yml·프로젝트 파일에 버전을 쓰지 못했다 — 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 값과 첫 릴리스 때 읽은 값이 어긋난다.
+_CORE_VERSION_RE = re.compile(r"^v?(\d+\.\d+\.\d+)(?:[-+][0-9A-Za-z.+-]*)?$")
+
+# Gradle·Maven의 -SNAPSHOT은 특정 버전의 프리릴리스가 아니라 "개발 중 빌드" 표식이다(배포 저장소 선택,
+# 산출물 이름에 쓰인다). 그래서 버전을 올려도 떼지 않고 새 버전 뒤에 그대로 붙인다.
+# rc.1·beta.1 같은 프리릴리스는 그 버전 전용 표식이라 새 x.y.z로 릴리스할 때 버린다.
+SNAPSHOT_SUFFIX = "-SNAPSHOT"
+
+
+def core_version(value):
+    """x.y.z[-pre][+build] → x.y.z. 버전 형식이 아니면 None."""
+    m = _CORE_VERSION_RE.match(str(value or "").strip())
+    return m.group(1) if m else None
+
+
+def _keep_snapshot(old_value, new_version):
+    return new_version + SNAPSHOT_SUFFIX if str(old_value).endswith(SNAPSHOT_SUFFIX) else new_version
+
 
 def log(message):
     """Non-value logging output, written to stderr (mirroring the bash
@@ -185,12 +213,15 @@ def get_project_types_csv():
 def get_type_path(project_type, project_types_list=None):
     """Return project_paths.<type> if set, else '.' (repo root)."""
     text = read_text()
-    m = re.search(r'^project_paths:[ \t]*\n((?:[ \t]+.+\n?)+)', text, re.MULTILINE)
+    # The wizard writes trailing comments on both the key line and value lines
+    # (e.g. `project_paths: # ...`, `  flutter: "app" # app/pubspec.yaml`).
+    m = re.search(r'^project_paths:[ \t]*(?:#[^\n]*)?\n((?:[ \t]+.+\n?)+)', text, re.MULTILINE)
     if not m:
         return "."
     block = m.group(1)
     km = re.search(
-        r'^[ \t]+["\']?' + re.escape(project_type) + r'["\']?:[ \t]*["\']?([^"\'\n]+?)["\']?[ \t]*$',
+        r'^[ \t]+["\']?' + re.escape(project_type)
+        + r'["\']?:[ \t]*["\']?([^"\'#\n]+?)["\']?[ \t]*(?:#.*)?$',
         block,
         re.MULTILINE,
     )
@@ -283,7 +314,18 @@ def get_higher_version(v1, v2):
 
 
 def update_version_yml(new_version):
-    write_scalar_key("version", new_version)
+    if not write_scalar_key("version", new_version):
+        # 키가 없으면 아무것도 쓰지 않은 채 성공처럼 끝나 매번 같은 버전이 나왔다.
+        log("WARNING: version field missing in version.yml, adding it")
+        text = read_text()
+        line = f'version: "{new_version}"\n'
+        if re.search(r'^version_code:', text, re.MULTILINE):
+            new_text = re.sub(r'^(?=version_code:)', lambda _m: line, text, count=1, flags=re.MULTILINE)
+        else:
+            new_text = text.rstrip("\n") + "\n" + line
+        write_text(new_text)
+    if read_scalar_key("version") != new_version:
+        raise VersionSyncError(f"failed to write version {new_version} to version.yml")
     today = datetime.date.today().isoformat()
     user = os.environ.get("GITHUB_ACTOR", "")
     if not user:
@@ -316,24 +358,139 @@ def _write_nested_scalar(key, value):
 # Project file sync (type-specific)
 # ===================================================================
 
+_XML_TOKEN_RE = re.compile(
+    r'<!--.*?-->|<!\[CDATA\[.*?\]\]>|<\?.*?\?>|<![^>]*>|<(/?)([A-Za-z_][\w.:-]*)[^>]*?(/?)>',
+    re.DOTALL,
+)
+
+
+def _pom_text_span(text, path):
+    """루트(<project>) 기준 경로의 요소 텍스트 구간 (start, end). 없으면 None.
+    <parent>·<dependencies> 안의 <version>은 다른 아티팩트 버전이라 깊이로 구분한다."""
+    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):  # 닫는 태그
+            if start is not None and stack[1:] == target:
+                return start, m.start()
+            if stack:
+                stack.pop()
+            continue
+        if m.group(3):  # <tag/>
+            continue
+        stack.append(name)
+        if stack[1:] == target:
+            start = m.end()
+    return None
+
+
+def _pom_text(text, path):
+    span = _pom_text_span(text, path)
+    return text[span[0]:span[1]].strip() if span else None
+
+
+def _pom_replace(text, path, value):
+    span = _pom_text_span(text, path)
+    if not span:
+        return text, False
+    return text[:span[0]] + value + text[span[1]:], True
+
+
+def sync_maven(path_dir, new_version):
+    """pom.xml의 프로젝트 자신의 <version>만 바꾼다. 하위 모듈은 루트를 가리키는
+    <parent><version>(과 루트와 같던 자기 <version>)만 따라 올린다."""
+    root_pom = Path(path_dir) / "pom.xml"
+    if not root_pom.is_file():
+        return False
+    text = read_file(root_pom)
+    old_version = _pom_text(text, ["version"])
+    if old_version is None:
+        log(f"WARNING: spring: {root_pom} has no project <version> (inherited from parent?) — skipping")
+        return True
+    if "${" in old_version:
+        # ${revision} 같은 CI-friendly 버전은 프로퍼티 쪽에서 관리하므로 건드리지 않는다.
+        log(f"WARNING: spring: {root_pom} <version> is a property ({old_version}) — skipping")
+        return True
+    new_full = _keep_snapshot(old_version, new_version)
+    new_text, _ = _pom_replace(text, ["version"], new_full)
+    write_file(root_pom, new_text)
+    log(f"updated: {root_pom}")
+
+    root_artifact = _pom_text(text, ["artifactId"])
+    for child in sorted(Path(path_dir).glob("*/pom.xml")):
+        ctext = read_file(child)
+        if _pom_text(ctext, ["parent", "artifactId"]) != root_artifact:
+            continue
+        if _pom_text(ctext, ["parent", "version"]) != old_version:
+            continue
+        ctext, _ = _pom_replace(ctext, ["parent", "version"], new_full)
+        if _pom_text(ctext, ["version"]) == old_version:
+            ctext, _ = _pom_replace(ctext, ["version"], new_full)
+        write_file(child, ctext)
+        log(f"updated: {child}")
+    return True
+
+
+_GRADLE_VERSION_RE = re.compile(r"""^([ \t]*version[ \t]*=[ \t]*)(['"])([^'"\n]*)\2""", re.MULTILINE)
+
+
 def sync_spring(path_dir, new_version):
-    """Look for build.gradle or build.gradle.kts under path_dir (root of that dir, like bash's maxdepth 2)."""
+    """Look for build.gradle or build.gradle.kts under path_dir (root of that dir, like bash's maxdepth 2),
+    and pom.xml for Maven projects."""
     candidates = []
     for name in ("build.gradle", "build.gradle.kts"):
         for p in [Path(path_dir) / name] + list(Path(path_dir).glob("*/" + name)):
             if p.is_file():
                 candidates.append(p)
+    has_pom = sync_maven(path_dir, new_version)
     if not candidates:
-        log(f"WARNING: spring: no build.gradle(.kts) found under {path_dir} — skipping")
+        if not has_pom:
+            log(f"WARNING: spring: no build.gradle(.kts) or pom.xml found under {path_dir} — skipping")
         return
     for gradle_file in candidates:
         text = read_file(gradle_file)
-        new_text = re.sub(r"version\s*=\s*'[^']*'", f"version = '{new_version}'", text)
-        new_text = re.sub(r'version\s*=\s*"[^"]*"', f'version = "{new_version}"', new_text)
+        # 줄 시작의 `version =`만 프로젝트 버전이다. 앵커가 없으면 kotlin_version 같은
+        # 의존성 버전 변수까지 함께 바뀌어 빌드가 깨진다.
+        new_text, count = _GRADLE_VERSION_RE.subn(
+            lambda m: f"{m.group(1)}{m.group(2)}{_keep_snapshot(m.group(3), new_version)}{m.group(2)}", text,
+        )
+        if count == 0:
+            log(f"WARNING: spring: no `version = '...'` line in {gradle_file} — skipping")
+            continue
         write_file(gradle_file, new_text)
         log(f"updated: {gradle_file}")
 
 
+def _pubspec_build_number(path_dir):
+    """pubspec.yaml `version: x.y.z+N`의 N. 없으면 None."""
+    target = Path(path_dir) / "pubspec.yaml"
+    if not target.is_file():
+        return None
+    m = re.search(r'^version:[ \t]*[^\s#+]+\+(\d+)', read_file(target), re.MULTILINE)
+    return int(m.group(1)) if m else None
+
+
+def get_reconciled_version_code():
+    """version.yml의 version_code와 pubspec.yaml의 +N 중 큰 값.
+    로컬 수동 배포 등으로 pubspec 쪽이 앞서 있으면 스토어는 더 작은 build number를
+    거부하므로, 그 값을 version.yml에 반영해 역행을 막는다."""
+    code = int(get_version_code())
+    types = get_project_types_csv()
+    pubspec_codes = [
+        n for n in (_pubspec_build_number(get_type_path(t)) for t in types if t == "flutter")
+        if n is not None
+    ]
+    if pubspec_codes and max(pubspec_codes) > code:
+        log(f"pubspec.yaml build number {max(pubspec_codes)} is ahead of version_code {code} — adopting it")
+        code = max(pubspec_codes)
+        set_version_code(code)
+    return code
+
+
 def sync_flutter(path_dir, new_version, version_code):
     target = Path(path_dir) / "pubspec.yaml"
     if not target.is_file():
@@ -350,32 +507,83 @@ def sync_flutter(path_dir, new_version, version_code):
     log(f"updated: {target}")
 
 
+def _json_indent(text):
+    """Indentation used by an existing JSON file — the first indented line after a newline
+    (e.g. 4 spaces or a tab). Single-line JSON stays on one line (None).
+    Rewriting with a fixed indent turns every version bump into a whole-file diff."""
+    if "\n" not in text.strip():
+        return None
+    m = re.search(r'\n([ \t]+)\S', text)
+    return m.group(1) if m else 2
+
+
 def sync_json_version(target, new_version, key_path):
     if not target.is_file():
         log(f"WARNING: {target} not found — skipping")
         return
+    raw = read_file(target)
     try:
-        data = json.loads(read_file(target))
+        data = json.loads(raw)
     except json.JSONDecodeError as e:
-        log(f"WARNING: {target} invalid JSON ({e}) — skipping")
-        return
+        # 건너뛰고 성공으로 끝내면 태그·version.yml과 패키지 버전이 조용히 어긋난다.
+        raise VersionSyncError(f"{target} is not valid JSON ({e}) — cannot write version")
     node = data
     for k in key_path[:-1]:
         node = node.setdefault(k, {})
     node[key_path[-1]] = new_version
-    write_file(target, json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    write_file(target, json.dumps(data, indent=_json_indent(raw), ensure_ascii=False) + "\n")
     log(f"updated: {target}")
 
 
+_TOML_HEADER_RE = re.compile(r'^[ \t]*\[+[ \t]*([^\]\n]+?)[ \t]*\]+[ \t]*(?:#.*)?$', re.MULTILINE)
+_TOML_VERSION_RE = re.compile(r'^[ \t]*version[ \t]*=[ \t]*([\'"])([^\'"\n]*)\1', re.MULTILINE)
+
+
+def _pyproject_version_span(text):
+    """[project] 또는 [tool.poetry] 섹션의 version 값 구간. [tool.*] 등 다른 섹션의
+    `version =`은 도구 설정이라 패키지 버전으로 쓰지 않는다."""
+    headers = list(_TOML_HEADER_RE.finditer(text))
+    for i, h in enumerate(headers):
+        if h.group(1) not in ("project", "tool.poetry"):
+            continue
+        end = headers[i + 1].start() if i + 1 < len(headers) else len(text)
+        m = _TOML_VERSION_RE.search(text, h.end(), end)
+        if m:
+            return m.start(2), m.end(2)
+    return None
+
+
+# setup(version="x.y.z"). python_requires·python_version 같은 다른 키는 앞 글자로 거른다.
+_SETUP_PY_VERSION_RE = re.compile(r"""(?<![\w.])version\s*=\s*(['"])([^'"]+)\1""")
+
+
+def _python_version_spans(path_dir):
+    """버전을 읽고 쓰는 파일과 값 구간 목록. 읽을 때는 앞쪽(pyproject.toml → setup.py)이 우선이다.
+    setup.py만 쓰는 프로젝트도 설치 때 버전을 읽으므로, 릴리스 때도 같은 파일을 읽고 써야 한다."""
+    spans = []
+    pyproject = Path(path_dir) / "pyproject.toml"
+    if pyproject.is_file():
+        span = _pyproject_version_span(read_file(pyproject))
+        if span:
+            spans.append((pyproject, span))
+    setup_py = Path(path_dir) / "setup.py"
+    if setup_py.is_file():
+        m = _SETUP_PY_VERSION_RE.search(read_file(setup_py))
+        if m:
+            spans.append((setup_py, (m.start(2), m.end(2))))
+    return spans
+
+
 def sync_python(path_dir, new_version):
-    target = Path(path_dir) / "pyproject.toml"
-    if not target.is_file():
-        log(f"WARNING: python: {target} not found — skipping")
+    spans = _python_version_spans(path_dir)
+    if not spans:
+        # dynamic = ["version"] 등 버전을 파일에 두지 않는 구성은 쓸 곳이 없다.
+        log(f"WARNING: python: no version in pyproject.toml [project]/[tool.poetry] or setup.py under {path_dir} — skipping")
         return
-    text = read_file(target)
-    new_text = re.sub(r'^version\s*=\s*"[^"]*"', f'version = "{new_version}"', text, count=1, flags=re.MULTILINE)
-    write_file(target, new_text)
-    log(f"updated: {target}")
+    for target, (start, end) in spans:
+        text = read_file(target)
+        write_file(target, text[:start] + new_version + text[end:])
+        log(f"updated: {target}")
 
 
 def sync_react_native(path_dir, new_version):
@@ -411,24 +619,11 @@ def sync_react_native(path_dir, new_version):
 
 def sync_for_type(project_type, new_version, version_code_getter):
     path_dir = get_type_path(project_type)
-    if project_type == "spring":
-        sync_spring(path_dir, new_version)
-    elif project_type == "flutter":
-        sync_flutter(path_dir, new_version, version_code_getter())
-    elif project_type in ("react", "next", "node"):
-        sync_json_version(Path(path_dir) / "package.json", new_version, ["version"])
-    elif project_type == "python":
-        sync_python(path_dir, new_version)
-    elif project_type == "react-native":
-        sync_react_native(path_dir, new_version)
-    elif project_type == "react-native-expo":
-        sync_json_version(Path(path_dir) / "app.json", new_version, ["expo", "version"])
-    elif project_type == "basic":
-        pass
-    elif project_type == "go":
-        pass
-    else:
+    handler = TYPE_HANDLERS.get(project_type)
+    if handler is None:
         log(f"WARNING: unknown project type: {project_type} — skipping")
+        return
+    handler.sync(path_dir, new_version, version_code_getter)
 
 
 def sync_all_project_files(new_version):
@@ -437,74 +632,176 @@ def sync_all_project_files(new_version):
         # No silent fallback: an unreadable project_types used to degrade to
         # "basic" and skip every sync without a word.
         raise SystemExit("ERROR: version.yml has no readable project_types — cannot sync project files")
+    errors = []
     for t in types:
-        sync_for_type(t, new_version, get_version_code)
+        # 한 타입이 실패해도 나머지는 맞춰 두고, 실패는 끝에서 모아 종료 코드로 알린다.
+        try:
+            sync_for_type(t, new_version, get_reconciled_version_code)
+        except VersionSyncError as e:
+            log(f"ERROR: {t}: {e}")
+            errors.append(t)
+    if errors:
+        raise VersionSyncError(f"project file sync failed for: {', '.join(errors)}")
+
+
+README_VERSION_LINE_RE = re.compile(
+    r"^(##[^:\n]*:[ \t]*)v?\d+\.\d+\.\d+([ \t]*\(\d{4}-\d{2}-\d{2}\))?[ \t]*$", re.MULTILINE)
+
+
+def update_readme_version(new_version, path="README.md"):
+    """AUTO-VERSION-SECTION 마커 바로 아래 버전 줄만 새 버전으로 바꾼다.
+
+    README 갱신 워크플로우는 태그를 만든 뒤에 돌기 때문에, 버전 확정 커밋에 README가 함께
+    들어가지 않으면 태그 시점 README가 한 버전 전을 가리킨다. 마커·줄 삽입 같은 나머지 일은
+    그 워크플로우에 맡기고, 여기서는 이미 있는 줄만 고친다(날짜 표기 여부도 그대로 둔다)."""
+    p = Path(path)
+    if not p.is_file():
+        return False
+    text = read_file(p)
+    lines = text.split("\n")
+    for i, line in enumerate(lines[:-1]):
+        if "AUTO-VERSION-SECTION" not in line:
+            continue
+        m = README_VERSION_LINE_RE.match(lines[i + 1])
+        if not m:
+            return False
+        date = f" ({datetime.date.today().isoformat()})" if m.group(2) else ""
+        new_line = f"{m.group(1)}v{new_version}{date}"
+        if new_line == lines[i + 1]:
+            return False
+        lines[i + 1] = new_line
+        write_file(p, "\n".join(lines))
+        log(f"README.md version line -> v{new_version}")
+        return True
+    return False
 
 
 def update_all_versions(new_version):
     update_version_yml(new_version)
     sync_all_project_files(new_version)
+    update_readme_version(new_version)
 
 
 # ===================================================================
-# Project file -> version read-back (for sync comparison)
+# Project file -> version read-back, and the per-type handler table
 # ===================================================================
 
+def _read_spring(path_dir):
+    # build.gradle에 버전이 없으면(allprojects 설정만 있는 경우 등) build.gradle.kts → pom.xml 순으로 이어 본다.
+    for name in ("build.gradle", "build.gradle.kts"):
+        p = Path(path_dir) / name
+        if p.is_file():
+            for m in _GRADLE_VERSION_RE.finditer(read_file(p)):
+                version = core_version(m.group(3))
+                if version:
+                    return version
+    pom = Path(path_dir) / "pom.xml"
+    if pom.is_file():
+        return core_version(_pom_text(read_file(pom), ["version"]))
+    return None
+
+
+def _read_flutter(path_dir):
+    p = Path(path_dir) / "pubspec.yaml"
+    if p.is_file():
+        text = p.read_text(encoding="utf-8")
+        m = re.search(r'^version:\s*([^\s#]+)', text, re.MULTILINE)
+        if m:
+            return core_version(m.group(1))
+    return None
+
+
+def _read_package_json(path_dir):
+    p = Path(path_dir) / "package.json"
+    if p.is_file():
+        data = json.loads(p.read_text(encoding="utf-8"))
+        return core_version(data.get("version"))
+    return None
+
+
+def _read_react_native(path_dir):
+    """릴리스 때 쓰는 파일(ios/<앱>/Info.plist, android/app/build.gradle)에서 읽는다.
+    package.json version은 동기화하지 않으므로 기준으로 삼으면 매 릴리스마다 어긋난다.
+    $(MARKETING_VERSION) 참조나 템플릿 기본값 "1.0"처럼 x.y.z가 아닌 값은 건너뛴다."""
+    ios_dir = Path(path_dir) / "ios"
+    if ios_dir.is_dir():
+        # rglob 첫 결과는 파일시스템 순서라 Pods·테스트 타깃 plist가 걸릴 수 있다 — 앱 폴더 한 단계만, 이름순.
+        for plist in sorted(ios_dir.glob("*/Info.plist")):
+            m = re.search(r'<key>CFBundleShortVersionString</key>\s*<string>([^<]*)</string>', read_file(plist))
+            version = core_version(m.group(1)) if m else None
+            if version:
+                return version
+    gradle_file = Path(path_dir) / "android" / "app" / "build.gradle"
+    if gradle_file.is_file():
+        m = re.search(r'versionName\s+"([^"]+)"', read_file(gradle_file))
+        if m:
+            return core_version(m.group(1))
+    return None
+
+
+def _read_expo(path_dir):
+    p = Path(path_dir) / "app.json"
+    if p.is_file():
+        data = json.loads(p.read_text(encoding="utf-8"))
+        return core_version((data.get("expo") or {}).get("version"))
+    return None
+
+
+def _read_python(path_dir):
+    for target, (start, end) in _python_version_spans(path_dir):
+        version = core_version(read_file(target)[start:end])
+        if version:
+            return version
+    return None
+
+
+def _read_none(path_dir):
+    return None
+
+
+def _sync_none(path_dir, new_version, version_code_getter):
+    pass
+
+
+class TypeHandler(NamedTuple):
+    """타입별 버전 파일 처리. read(path_dir)는 파일의 버전(없으면 None),
+    sync(path_dir, new_version, version_code_getter)는 새 버전을 파일에 쓴다."""
+    read: Callable
+    sync: Callable
+
+
+_PACKAGE_JSON = TypeHandler(
+    read=_read_package_json,
+    sync=lambda d, v, _code: sync_json_version(Path(d) / "package.json", v, ["version"]),
+)
+
+# 새 타입은 여기 한 줄만 추가하면 읽기(sync 비교)와 쓰기가 함께 따라온다.
+# 버전 파일이 없는 타입(basic·go)은 version.yml만 쓰도록 빈 핸들러를 둔다.
+TYPE_HANDLERS = {
+    "spring": TypeHandler(read=_read_spring, sync=lambda d, v, _code: sync_spring(d, v)),
+    # build number가 필요한 타입만 version_code를 계산한다 (pubspec 조정 부수효과가 있다).
+    "flutter": TypeHandler(read=_read_flutter, sync=lambda d, v, code: sync_flutter(d, v, code())),
+    "react": _PACKAGE_JSON,
+    "next": _PACKAGE_JSON,
+    "node": _PACKAGE_JSON,
+    "python": TypeHandler(read=_read_python, sync=lambda d, v, _code: sync_python(d, v)),
+    "react-native": TypeHandler(read=_read_react_native, sync=lambda d, v, _code: sync_react_native(d, v)),
+    "react-native-expo": TypeHandler(
+        read=_read_expo,
+        sync=lambda d, v, _code: sync_json_version(Path(d) / "app.json", v, ["expo", "version"]),
+    ),
+    "basic": TypeHandler(read=_read_none, sync=_sync_none),
+    "go": TypeHandler(read=_read_none, sync=_sync_none),
+}
+
+
 def get_project_file_version(project_type):
     path_dir = get_type_path(project_type)
+    handler = TYPE_HANDLERS.get(project_type)
     version = None
     try:
-        if project_type == "spring":
-            for name in ("build.gradle", "build.gradle.kts"):
-                p = Path(path_dir) / name
-                if p.is_file():
-                    text = p.read_text(encoding="utf-8")
-                    m = re.search(r"^\s*version\s*=\s*['\"](\d+\.\d+\.\d+)['\"]", text, re.MULTILINE)
-                    if m:
-                        version = m.group(1)
-                    break
-        elif project_type == "flutter":
-            p = Path(path_dir) / "pubspec.yaml"
-            if p.is_file():
-                text = p.read_text(encoding="utf-8")
-                m = re.search(r'^version:\s*([^\s#]+)', text, re.MULTILINE)
-                if m:
-                    version = m.group(1).split("+")[0]
-        elif project_type in ("react", "next", "node"):
-            p = Path(path_dir) / "package.json"
-            if p.is_file():
-                data = json.loads(p.read_text(encoding="utf-8"))
-                version = data.get("version")
-        elif project_type == "react-native":
-            ios_dir = Path(path_dir) / "ios"
-            plist = None
-            if ios_dir.is_dir():
-                plists = list(ios_dir.rglob("Info.plist"))
-                plist = plists[0] if plists else None
-            if plist is not None:
-                text = plist.read_text(encoding="utf-8")
-                m = re.search(r'<key>CFBundleShortVersionString</key>\s*<string>([^<]*)</string>', text)
-                if m:
-                    version = m.group(1)
-            else:
-                gradle_file = Path(path_dir) / "android" / "app" / "build.gradle"
-                if gradle_file.is_file():
-                    text = gradle_file.read_text(encoding="utf-8")
-                    m = re.search(r'versionName\s+"([^"]+)"', text)
-                    if m:
-                        version = m.group(1)
-        elif project_type == "react-native-expo":
-            p = Path(path_dir) / "app.json"
-            if p.is_file():
-                data = json.loads(p.read_text(encoding="utf-8"))
-                version = (data.get("expo") or {}).get("version")
-        elif project_type == "python":
-            p = Path(path_dir) / "pyproject.toml"
-            if p.is_file():
-                text = p.read_text(encoding="utf-8")
-                m = re.search(r'^version\s*=\s*"(\d+\.\d+\.\d+)"', text, re.MULTILINE)
-                if m:
-                    version = m.group(1)
+        if handler is not None:
+            version = handler.read(path_dir)
     except Exception as e:
         log(f"WARNING: failed reading project file for {project_type}: {e}")
         version = None
@@ -560,14 +857,14 @@ def cmd_get(args):
 
 def cmd_get_code(args):
     require_version_yml()
-    code = get_version_code()
+    code = get_reconciled_version_code()
     print(code)
     return 0
 
 
 def cmd_increment_code(args):
     require_version_yml()
-    current = int(get_version_code())
+    current = get_reconciled_version_code()
     new_code = current + 1
     set_version_code(new_code)
     print(new_code)
@@ -582,11 +879,10 @@ def cmd_increment(args):
         return 1
     bump = getattr(args, "bump", None) or "patch"
     new_version = increment_version(current_version, bump)
+    # build number를 먼저 올려야 이어지는 pubspec 동기화에 새 값이 함께 기록된다.
+    set_version_code(get_reconciled_version_code() + 1)
     update_all_versions(new_version)
 
-    current_code = int(get_version_code())
-    set_version_code(current_code + 1)
-
     print(new_version)
     return 0
 
@@ -640,7 +936,11 @@ def main(argv=None):
         "sync": cmd_sync,
     }
     handler = handlers[args.command]
-    return handler(args)
+    try:
+        return handler(args)
+    except VersionSyncError as e:
+        log(f"ERROR: {e}")
+        return 1
 
 
 if __name__ == "__main__":

package/payload/version.yml.template

@@ -18,14 +18,16 @@
 #   (e.g., flutter: "app", react: "client"). Omitted -> repo root.
 #
 # Synced files per type:
-# - spring: build.gradle / build.gradle.kts
+# - spring: build.gradle / build.gradle.kts / pom.xml
 # - flutter: pubspec.yaml
 # - next/react/node: package.json
 # - react-native: Info.plist + build.gradle
 # - react-native-expo: app.json
-# - python: pyproject.toml
+# - python: pyproject.toml / setup.py
 # - go: (none — git tag based, go.mod has no version field)
 # - basic: version.yml only
+# A file version like 1.2.0-rc.1 or 1.2.0+4 is read as 1.2.0 (version below is x.y.z only).
+# Gradle/Maven -SNAPSHOT is kept when the version is bumped (1.2.0-SNAPSHOT -> 1.2.1-SNAPSHOT).
 # ===
 
 version: "{{VERSION}}"