✨ feat: static versioning via gradle.properties (#6)

* 🚧 chore: seed gradle.properties with current version values

* ✨ feat: read app version from gradle.properties instead of git describe

* 🔥 chore: remove buildSrc/ — no longer needed with static versioning

* 👷 ci: bump+tag gradle.properties on main, read static on PR

* 👷 ci: drop QUIRE_VERSION_FALLBACK from release job, checkout the freshly-pushed tag

* 👷 ci(codeql): drop QUIRE_VERSION_FALLBACK and fetch-tags

* 📝 docs: rewrite release.md for static gradle.properties versioning

Author: vitofico

.github/workflows/android-ci.yaml

@@ -37,6 +37,8 @@ concurrency:
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write   # to push the version-bump commit and tag
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
@@ -54,23 +56,38 @@ jobs:
       - uses: gradle/actions/setup-gradle@ed408507eac070d1f99cc633dbcf757c94c7933a # v4
       - id: version
         name: Compute version
+        env:
+          # Use the GitHub-provided token to push the bump commit and tag.
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           if [ "$GITHUB_REF" = "refs/heads/main" ]; then
-            # On main: bump CalVer (date + CI run number) and tag the HEAD
-            # locally so Gradle's git-describe finds an exact-match tag.
-            # The release job pushes this tag when it creates the Release.
+            # On main: compute the next CalVer from date + run number,
+            # write it into gradle.properties, commit + tag, then push
+            # both before Gradle runs. The build then reads the bumped
+            # values directly from gradle.properties.
             BUILD_DATE=$(date -u +%Y-%m-%d)
-            VERSION="${BUILD_DATE//-/.}.${GITHUB_RUN_NUMBER}"
-            git tag "v$VERSION"
+            NEW_NAME="${BUILD_DATE//-/.}.${GITHUB_RUN_NUMBER}"
+            YY=$(date -u +%y)
+            MM=$(date -u +%m)
+            DD=$(date -u +%d)
+            NEW_CODE=$(( (10#$YY * 10000 + 10#$MM * 100 + 10#$DD) * 100 + GITHUB_RUN_NUMBER % 100 ))
+
+            sed -i "s/^VERSION_NAME=.*/VERSION_NAME=$NEW_NAME/" gradle.properties
+            sed -i "s/^VERSION_CODE=.*/VERSION_CODE=$NEW_CODE/" gradle.properties
+
+            git config user.name "github-actions[bot]"
+            git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+            git remote set-url origin "https://x-access-token:${GH_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+            git add gradle.properties
+            git commit -m ":bookmark: chore: release v$NEW_NAME"
+            git tag "v$NEW_NAME"
+            git push origin "HEAD:$GITHUB_REF" "v$NEW_NAME"
+
+            VERSION="$NEW_NAME"
           else
-            # On PRs / feature branches: derive from existing tag history.
-            # Post-tag dev format is fine for non-release artifact names.
-            if ! git describe --tags --match 'v*' --abbrev=0 >/dev/null 2>&1; then
-              echo "::error::No matching v* tag in history. Build will fail."
-              git tag -l 'v*' | head
-              exit 1
-            fi
-            VERSION=$(git describe --tags --match 'v*' --always | sed 's/^v//')
+            # On PRs / feature branches: just read the static value from
+            # gradle.properties — no bump, no tag, no commit.
+            VERSION=$(grep '^VERSION_NAME=' gradle.properties | cut -d= -f2)
           fi
           echo "VERSION_NAME=$VERSION" >> "$GITHUB_ENV"
           echo "version=$VERSION" >> "$GITHUB_OUTPUT"
@@ -102,6 +119,7 @@ jobs:
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
+          ref: v${{ needs.build.outputs.version }}
           fetch-depth: 0
           fetch-tags: true
       - uses: actions/setup-java@c1e323688fd81a25caa38c78aa6df2d33d3e20d9 # v4
@@ -119,11 +137,6 @@ jobs:
           KEYSTORE_B64: ${{ secrets.QUIRE_RELEASE_KEYSTORE_B64 }}
       - name: Assemble release APK
         env:
-          # The build job created the tag locally on its runner so Gradle's
-          # git-describe found an exact match. Each release-job runner gets
-          # a fresh checkout with no local tag, so feed the same CalVer in
-          # via the parser's fallback path.
-          QUIRE_VERSION_FALLBACK: ${{ needs.build.outputs.version }}
           QUIRE_RELEASE_KEYSTORE: ${{ secrets.QUIRE_RELEASE_KEYSTORE_B64 != '' && format('{0}/release.keystore', runner.temp) || '' }}
           QUIRE_RELEASE_KEYSTORE_PASSWORD: ${{ secrets.QUIRE_RELEASE_KEYSTORE_PASSWORD }}
           QUIRE_RELEASE_KEY_ALIAS: ${{ secrets.QUIRE_RELEASE_KEY_ALIAS }}

.github/workflows/codeql.yaml

@@ -32,7 +32,6 @@ jobs:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
           fetch-depth: 0
-          fetch-tags: true
       - name: Initialize CodeQL
         uses: github/codeql-action/init@0daab03d71ff584ef619d027a3fd9146679c5d84 # v3
         with:
@@ -47,11 +46,6 @@ jobs:
         with:
           packages: "platform-tools platforms;android-34 build-tools;34.0.0"
       - if: matrix.language == 'java-kotlin'
-        env:
-          # CodeQL doesn't need a meaningful version — fall back to a fixed
-          # placeholder so the version derivation in app/build.gradle.kts
-          # succeeds even when no v* tag is reachable from this commit.
-          QUIRE_VERSION_FALLBACK: 2026.05.08.0
         run: ./gradlew assembleDebug -x test --stacktrace
       - if: matrix.language == 'python'
         uses: github/codeql-action/autobuild@0daab03d71ff584ef619d027a3fd9146679c5d84 # v3

app/build.gradle.kts

@@ -5,25 +5,10 @@ plugins {
     alias(libs.plugins.aboutlibraries)
 }
 
-// Tag-driven CalVer. The build reads `git describe --tags --match 'v*'`
-// and parses it via buildSrc/Version.kt. Set QUIRE_VERSION_FALLBACK
-// (e.g. "2026.05.08.29") if building from a shallow clone with no tags.
-fun gitDescribe(): String =
-    try {
-        val process = ProcessBuilder("git", "describe", "--tags", "--match", "v*", "--always")
-            .directory(rootDir)
-            .redirectErrorStream(true)
-            .start()
-        val output = process.inputStream.bufferedReader().readText().trim()
-        if (process.waitFor() == 0) output else ""
-    } catch (_: Exception) {
-        ""
-    }
-
-val versionInfo = Version.fromGitDescribe(
-    output = gitDescribe(),
-    fallback = System.getenv("QUIRE_VERSION_FALLBACK")
-)
+// Static version. Source of truth: gradle.properties (VERSION_NAME, VERSION_CODE).
+// CI bumps these on every push to main; local devs see the most recent release.
+val appVersionName: String = project.property("VERSION_NAME") as String
+val appVersionCode: Int = (project.property("VERSION_CODE") as String).toInt()
 
 // Drop the build timestamp from the AboutLibraries-generated license JSON
 // so the resource is byte-identical across rebuilds (matters for F-Droid's
@@ -40,8 +25,8 @@ android {
         applicationId = "io.theficos.quire"
         minSdk = 26
         targetSdk = 34
-        versionCode = versionInfo.code
-        versionName = versionInfo.name
+        versionCode = appVersionCode
+        versionName = appVersionName
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
     compileOptions {

buildSrc/build.gradle.kts

@@ -1,9 +1,12 @@
 # Release process
 
-Tag-driven. The `build` job in `android-ci.yaml` already pushes a
-`vYYYY.MM.DD.<run>` tag on every push to `main`. The tag push fires the
-workflow again, and the `release` job builds and signs a release APK
-and attaches it to a GitHub Release.
+Push-driven. Every push to `main` triggers `android-ci.yaml`. The
+`build` job bumps `VERSION_NAME` / `VERSION_CODE` in `gradle.properties`
+to the next CalVer (`YYYY.MM.DD.<run>` / `yyMMdd*100 + run%100`),
+commits with a `[bot]` author, tags `vYYYY.MM.DD.<run>`, and pushes
+both before Gradle runs. The `release` job then builds and signs a
+release APK from the freshly-pushed tag and attaches it to a GitHub
+Release.
 
 ## One-time keystore setup
 
@@ -35,18 +38,21 @@ testers but should not be your `latest` release.
 
 ## Cutting a release
 
-The `build` job pushes `vYYYY.MM.DD.<run>` tags on every push to
-`main`. The tag-trigger run does the rest. Nothing manual needed.
+Land a commit on `main`. The `build` job's *Compute version* step picks
+the next CalVer, writes it into `gradle.properties`, commits + tags +
+pushes, then builds. Nothing manual needed.
 
-To cut an out-of-band release, push a tag manually:
-
-```sh
-git tag v2026.05.07.0
-git push origin v2026.05.07.0
-```
+To cut an out-of-band release, push a no-op commit (e.g. `git commit
+--allow-empty -m ":bookmark: chore: trigger release"` followed by `git
+push`). Manually-pushed tags are not used by this workflow.
 
 ## Local release builds
 
+`gradle.properties` carries the version (`VERSION_NAME` and
+`VERSION_CODE`). Whatever's committed at HEAD is what the local build
+reports — if you want a specific version locally, edit those values
+before running.
+
 ```sh
 export QUIRE_RELEASE_KEYSTORE=/abs/path/to/quire-release.keystore
 export QUIRE_RELEASE_KEYSTORE_PASSWORD=...
@@ -98,17 +104,8 @@ it reports differences in `classes*.dex`, the build is non-reproducible
 — check JDK version, AGP version, and `gradle.properties` flags in
 the fdroidserver VM vs the CI runner.
 
-If `git describe` returns nothing inside the fdroidserver VM (it does
-a non-shallow clone, but on rare runs tags might not propagate),
-set `QUIRE_VERSION_FALLBACK` in the recipe's `Builds:` block:
-
-```yaml
-Builds:
-  - versionName: 2026.05.08.30
-    versionCode: 26050830
-    commit: v2026.05.08.30
-    subdir: app
-    gradle: [ yes ]
-    env:
-      QUIRE_VERSION_FALLBACK: 2026.05.08.30
-```
+The version values come from `gradle.properties` (`VERSION_NAME` and
+`VERSION_CODE`), which CI bumps on every push to `main` before the
+build runs. fdroidserver reads them via the recipe's `UpdateCheckData`
+line, so each tag's APK metadata is statically derivable from source
+without running Gradle.

buildSrc/src/main/kotlin/Version.kt

@@ -4,3 +4,8 @@ org.gradle.caching=true
 android.useAndroidX=true
 android.nonTransitiveRClass=true
 kotlin.code.style=official
+
+# App version. Bumped by CI on every push to main; locally these are the
+# values of the most recent release tag.
+VERSION_NAME=2026.05.08.43
+VERSION_CODE=26050843