@daemux/store-automator 0.10.96 → 0.10.97

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.96"
+    "version": "0.10.97"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.96",
+      "version": "0.10.97",
       "keywords": [
         "flutter",
         "app-store",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.96",
+  "version": "0.10.97",
   "description": "Full App Store & Google Play automation for Flutter apps with Claude Code agents",
   "type": "module",
   "bin": {

package/plugins/store-automator/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "store-automator",
-  "version": "0.10.96",
+  "version": "0.10.97",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"

package/templates/github/IOS_NATIVE_CI_SETUP.md

@@ -43,7 +43,11 @@ Subsequent builds need neither — the ASC API key handles everything.
 
 ## Step 4 — MARKETING_VERSION
 
-Leave your Xcode project's `MARKETING_VERSION` at `1.0` initially. CI auto-rolls the marketing version forward (patch bump) whenever the prior version hits `READY_FOR_SALE` in App Store Connect. Until then, the pipeline keeps bumping the build number against the current marketing version.
+Leave your Xcode project's `MARKETING_VERSION` at `1.0` initially.
+CI auto-rolls the marketing version forward (rollover bump — patch
+with carry at .9) whenever the prior version hits `READY_FOR_SALE` in
+App Store Connect. Until then, the pipeline keeps bumping the build
+number against the current marketing version.
 
 ### Auto-bumping MARKETING_VERSION
 
@@ -51,7 +55,33 @@ When the ASC combined floor (max of pending review, `preReleaseVersions`,
 or builds-via-`preReleaseVersion`) exceeds your project's
 `MARKETING_VERSION`, the action auto-bumps and commits the new value as
 part of the same bot commit that handles cert refresh / autoupdate.
-Default policy is `patch` — bumps the patch component.
+
+Default policy is `rollover` — patch with carry: at `.9` it rolls into
+the next minor (`1.0.9` → `1.1.0`), and at minor=9 it cascades into the
+next major (`1.9.9` → `2.0.0`). Major has no upper limit (`9.9.9` →
+`10.0.0` just keeps growing). This produces the more natural human
+progression most projects want — patch numbers never silently grow past
+9.
+
+**Four policies** are supported via the action input:
+
+| Policy | Example bump | When to use |
+|--------|--------------|-------------|
+| `rollover` (default) | `1.0.5` → `1.0.6`; `1.0.9` → `1.1.0` | Natural progression, carry at .9. |
+| `patch` | `1.0.5` → `1.0.6`; `1.0.9` → `1.0.10` | Legacy unbounded patch — pinned for backward compat. |
+| `minor` | `1.0.5` → `1.1.0`; `1.0.9` → `1.1.0` | Projects that ship every release as a minor. |
+| `none` | (fails the build) | Explicit semver control via human bump. |
+
+Full rollover behaviour: `1.0.9` → `1.1.0` (patch overflow), `1.9.9`
+→ `2.0.0` (minor cascade), `9.9.9` → `10.0.0` (major has no upper
+limit). The `patch` policy is preserved verbatim for consumers that
+pinned it before `rollover` shipped.
+
+**Backward compat:** existing consumers on `0.0.27` that explicitly pin
+`marketing-version-auto-bump: 'patch'` keep their current unbounded
+behavior — the `'patch'` policy is unchanged. The default change from
+`'patch'` → `'rollover'` only affects new installs and consumers that
+do not override the input.
 
 **Opt out** via the action input:
 
@@ -64,10 +94,6 @@ Default policy is `patch` — bumps the patch component.
 In `'none'` mode, the floor check fails the build and you must bump
 `MARKETING_VERSION` manually before retrying.
 
-**Policy `'minor'`** bumps the minor component (e.g. `1.0.5` → `1.1.0`)
-when floor exceeds project. Useful for projects where every release
-is a minor.
-
 **Side effect:** the bot commit subject reflects what was changed,
 e.g. `ci: refresh signing identity + bump MARKETING_VERSION [skip ci]`.
 

package/templates/scripts/ci/ios-native/mmv_floor_check.py

@@ -30,8 +30,11 @@ SEM_RE = re.compile(r"^(\d+)\.(\d+)(?:\.(\d+))?$")
 
 # DESIGN DECISION: auto-bump policy is read from the env var so the action
 # step can wire it from `inputs.marketing-version-auto-bump` without a
-# CLI-flag re-plumb of every helper. Default 'patch' matches the action
-# input default. ``'none'`` preserves the historical fail-the-build path.
+# CLI-flag re-plumb of every helper. Default 'rollover' matches the action
+# input default -- patch with carry at .9 (1.0.9 -> 1.1.0) is the more
+# natural semver progression for unattended CI. ``'patch'`` is preserved
+# unchanged for consumers pinning the historical (unbounded) behavior.
+# ``'none'`` preserves the historical fail-the-build path.
 _AUTO_BUMP_ENV = "MARKETING_VERSION_AUTO_BUMP"
 
 # DESIGN DECISION: auto-bump must only fire when the resulting bumped
@@ -139,7 +142,7 @@ def _floor_error(target: str, floor: str, per_source: dict, *, strict: bool) ->
     raise SystemExit(2)
 
 
-def _persist_context_ok() -> bool:
+def _persist_context_ok(policy: str) -> bool:
     """True when this run can persist a project-file bump back to the
     default branch via the action's commit-back step. The commit-back
     step is gated on ``event=push`` AND ``ref=refs/heads/<default>``;
@@ -149,7 +152,9 @@ def _persist_context_ok() -> bool:
 
     On refusal, emits the ``::warning::`` describing why this run
     cannot persist the bump (event/ref/default_branch values from the
-    environment). Side-effecting the warning here -- rather than at
+    environment). The warning names the active policy (rollover /
+    patch / minor) so consumers reading CI logs can see which mode
+    was attempted. Side-effecting the warning here -- rather than at
     the caller -- keeps ``maybe_auto_bump`` under the per-function LOC
     cap without splitting the env-read + warning into two helpers
     (which would also push the file over the per-file functions cap)."""
@@ -164,7 +169,7 @@ def _persist_context_ok() -> bool:
     if ok:
         return True
     print(
-        f"::warning::auto-bump=patch is enabled, but this run "
+        f"::warning::auto-bump={policy} is enabled, but this run "
         f"cannot persist the bump (event={event or '<unset>'}, "
         f"ref={ref or '<unset>'}, "
         f"default_branch={default_branch or '<unset>'}). The "
@@ -198,17 +203,17 @@ def maybe_auto_bump(target: str, floor: str) -> str | None:
     runs ``git add -f`` on the touched path so the auto-bump is staged
     in the index before any later step (e.g. prepare_signing) mutates
     the same file."""
-    policy = (os.environ.get(_AUTO_BUMP_ENV) or "patch").strip().lower()
+    policy = (os.environ.get(_AUTO_BUMP_ENV) or "rollover").strip().lower()
     if policy == "none":
         return None
-    if policy not in ("patch", "minor"):
+    if policy not in ("rollover", "patch", "minor"):
         print(
             f"::warning::Unknown {_AUTO_BUMP_ENV}={policy!r}; "
             f"falling back to fail-on-floor behavior",
             file=sys.stderr,
         )
         return None
-    if not _persist_context_ok():
+    if not _persist_context_ok(policy):
         return None
     new_version = version_utils.compute_next_version(target, floor, policy)
     if not version_utils.write_marketing_version(new_version):

package/templates/scripts/ci/ios-native/version_utils.py

@@ -12,10 +12,14 @@ the project's 10-functions-per-file cap. Two concerns live here:
        result > floor                (so ASC accepts the new row)
        result > current              (so the bump is observable)
 
-     Policy is ``'patch'`` (default) or ``'minor'``. Patch bumps the
-     patch component of max(floor.major.minor, current.major.minor) and
-     ensures it strictly exceeds both floor and current. Minor bumps the
-     minor component and resets patch to 0.
+     Policy is ``'rollover'`` (default), ``'patch'``, or ``'minor'``.
+     Rollover bumps the patch component with carry: at .9 it rolls
+     into the next minor (1.0.9 -> 1.1.0), and at minor=9, patch=9 it
+     cascades into the next major (1.9.9 -> 2.0.0). Major has no upper
+     limit (9.9.9 -> 10.0.0). Patch (legacy) bumps the patch component
+     unbounded (1.0.9 -> 1.0.10) -- preserved for backward compat with
+     consumers pinning the historical default. Minor bumps the minor
+     component and resets patch to 0.
 
   2. ``write_marketing_version(new_version)`` -- I/O. Writes
      ``new_version`` into the project's source-of-truth. Resolution order:
@@ -100,32 +104,49 @@ def compute_next_version(current: str, floor: str, policy: str) -> str:
     """Compute the next MARKETING_VERSION that satisfies both:
        result > floor    AND    result > current.
 
-    ``policy`` is ``'patch'`` or ``'minor'``. The ``'none'`` case is
-    handled by the caller (it preserves the existing fail-the-build
-    semantics) and never reaches this function."""
-    if policy not in ("patch", "minor"):
+    ``policy`` is ``'rollover'`` (default), ``'patch'``, or ``'minor'``.
+    The ``'none'`` case is handled by the caller (it preserves the
+    existing fail-the-build semantics) and never reaches this function.
+
+    Cross-train semantics (shared by 'patch' and 'rollover'): stay on
+    the higher major.minor train of (current, floor) so we never
+    silently advance an unrelated minor or major; when trains match,
+    base patch is max(current.patch, floor.patch). 'rollover' adds
+    carry: patch>9 rolls to patch=0, minor+=1; resulting minor>9
+    rolls to minor=0, major+=1; major has no upper limit (9.9.9 ->
+    10.0.0 just keeps growing). The ``>9`` (not ``==10``) check
+    handles inputs already past the rollover boundary -- e.g. a
+    project previously on the 'patch' policy that reached 1.0.10
+    before switching to 'rollover' must still cascade
+    (1.0.10 -> 1.1.0) rather than emit a malformed 1.0.11. 'patch'
+    (legacy) is unbounded (1.0.9 -> 1.0.10), preserved verbatim for
+    backward compat with consumers that pinned the historical default.
+    """
+    if policy not in ("rollover", "patch", "minor"):
         raise ValueError(f"unknown policy: {policy!r}")
-    cur = _parse(current)
-    fl = _parse(floor)
+    cur, fl = _parse(current), _parse(floor)
     if policy == "minor":
         major = max(cur[0], fl[0])
-        minor = max(cur[1], fl[1]) + 1
-        return f"{major}.{minor}.0"
-    # patch: stay on the higher major.minor train of (current, floor) so we
-    # never silently advance an unrelated minor or major. The patch number
-    # is +1 above whichever of (current, floor) shares that train; patches
-    # from the lower train are namespace-irrelevant and ignored.
+        return f"{major}.{max(cur[1], fl[1]) + 1}.0"
+    # patch / rollover share train resolution.
     if cur[:2] >= fl[:2]:
         major, minor, patch_base = cur[0], cur[1], cur[2]
-        # If current and floor share a major.minor, lift the patch above
-        # whichever is higher (floor by definition, since result must be
-        # > floor; current can equal floor only when cur[:2] == fl[:2]).
         if cur[:2] == fl[:2]:
             patch_base = max(cur[2], fl[2])
     else:
-        # Floor is on a higher train; jump to it and bump from its patch.
         major, minor, patch_base = fl
-    return f"{major}.{minor}.{patch_base + 1}"
+    if policy == "patch":
+        return f"{major}.{minor}.{patch_base + 1}"
+    # rollover: patch+1 with carry into minor, then into major.
+    # ``>9`` (not ``==10``) so inputs already over the boundary
+    # (e.g. a 1.0.10 left over from the legacy 'patch' policy)
+    # still cascade cleanly into the next minor / major train.
+    new_patch = patch_base + 1
+    if new_patch > 9:
+        new_patch, minor = 0, minor + 1
+    if minor > 9:
+        minor, major = 0, major + 1
+    return f"{major}.{minor}.{new_patch}"
 
 
 def _xcodebuild_args() -> tuple[list[str], Path]: