Add initial implementation of the ProGuard plugin

Author: NonSwag

packages/proguard-plugin/.gitignore

@@ -0,0 +1,2 @@
+build/
+.gradle/

packages/proguard-plugin/README.md

@@ -0,0 +1,135 @@
+# Proguard Plugin
+
+A Gradle plugin that uploads ProGuard/R8 obfuscation mapping files to the [Faststats](https://faststats.dev) sourcemaps
+API for stacktrace deobfuscation.
+
+## Installation
+
+Add the plugin to your project's `build.gradle.kts`:
+
+```kotlin
+plugins {
+    id("dev.faststats.proguard-mappings-upload") version "0.1.0"
+}
+```
+
+Or in Groovy (`build.gradle`):
+
+```groovy
+plugins {
+    id 'dev.faststats.proguard-mappings-upload' version '0.1.0'
+}
+```
+
+## Configuration
+
+### With a custom ProGuard task
+
+```kotlin
+mappingsUpload {
+    authToken.set("your-auth-token")
+    proguardTask.set(tasks.getByName("proguard"))
+    mappingFiles.from(layout.buildDirectory.file("proguard/mapping.txt"))
+}
+```
+
+Setting `proguardTask` ensures the upload task runs after ProGuard finishes. You still need to point `mappingFiles` to
+the actual mapping file location (matching your `printmapping` config).
+
+### Android Projects
+
+```kotlin
+mappingsUpload {
+    authToken.set("your-auth-token")
+}
+```
+
+The plugin automatically detects Android R8/ProGuard mapping file outputs when the Android Gradle Plugin is present. No
+additional configuration is needed.
+
+### All Options
+
+```kotlin
+mappingsUpload {
+    // Required – API auth token. Falls back to FASTSTATS_AUTH_TOKEN env var.
+    authToken.set("your-auth-token")
+
+    // Optional – API endpoint (default: https://sourcemaps.faststats.dev/api/sourcemaps)
+    endpoint.set("https://sourcemaps.faststats.dev/api/sourcemaps")
+
+    // Optional – Build identifier (default: project.version)
+    buildId.set("1.2.3")
+
+    // Optional – Task that produces the mapping file (adds a dependsOn)
+    proguardTask.set(tasks.getByName("proguard"))
+
+    // Optional – Mapping files to upload (default: build/obfuscation-mappings.txt)
+    mappingFiles.from(layout.buildDirectory.file("proguard/mapping.txt"))
+}
+```
+
+## Usage
+
+Run the upload task:
+
+```bash
+./gradlew uploadProguardMappings
+```
+
+Or chain it after your obfuscation task:
+
+```bash
+./gradlew proguard uploadProguardMappings
+```
+
+## CI Configuration
+
+### GitHub Actions
+
+```yaml
+name: Build & Upload Mappings
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Build & Upload
+        run: ./gradlew proguard uploadProguardMappings
+        env:
+          FASTSTATS_AUTH_TOKEN: ${{ secrets.FASTSTATS_AUTH_TOKEN }}
+```
+
+### GitLab CI
+
+```yaml
+build:
+  stage: build
+  script:
+    - ./gradlew proguard uploadProguardMappings
+  variables:
+    FASTSTATS_AUTH_TOKEN: $FASTSTATS_AUTH_TOKEN
+```
+
+## How It Works
+
+1. The plugin looks for mapping files added via `mappingFiles.from(...)`, or auto-detected Android build outputs.
+2. If `proguardTask` is set, the upload task automatically depends on it.
+3. Uses `project.version` as the `buildId` by default.
+4. Each mapping file is split by class sections and uploaded in batches of up to 50MB, ensuring no class mapping is
+   split across batches.
+
+## Requirements
+
+- Gradle 7.0+
+- JDK 11+

packages/proguard-plugin/build.gradle.kts

@@ -0,0 +1,59 @@
+plugins {
+    kotlin("jvm") version "2.3.20"
+    id("java-gradle-plugin")
+    id("maven-publish")
+}
+
+group = "dev.faststats"
+version = "0.1.0"
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation("com.google.code.gson:gson:2.13.1")
+    compileOnly("com.android.tools.build:gradle:8.7.3")
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+kotlin {
+    jvmToolchain(11)
+}
+
+gradlePlugin {
+    plugins {
+        create("proguardMappingsUpload") {
+            id = "dev.faststats.proguard-mappings-upload"
+            implementationClass = "dev.faststats.proguard.FastStatsProguardPlugin"
+            displayName = "Faststats ProGuard Mapping Upload Plugin"
+            description = "Uploads ProGuard/R8 obfuscation mapping files to the FastStats sourcemaps API"
+        }
+    }
+}
+
+publishing {
+    publications.create<MavenPublication>("maven") {
+        // pom.url.set("https://docs.faststats.dev/serviceio")
+        pom.scm {
+            val repository = "FastStats-dev/sourcemaps"
+            url.set("https://github.com/$repository/tree/main/packages/proguard-plugin")
+            connection.set("scm:git:git://github.com/$repository.git")
+            developerConnection.set("scm:git:ssh://github.com/$repository.git")
+        }
+        from(components["java"])
+    }
+    repositories.maven {
+        val branch = if (version.toString().contains("-pre")) "snapshots" else "releases"
+        url = uri("https://repo.thenextlvl.net/$branch")
+        credentials {
+            username = System.getenv("REPOSITORY_USER")
+            password = System.getenv("REPOSITORY_TOKEN")
+        }
+    }
+}

packages/proguard-plugin/gradle/wrapper/gradle-wrapper.jar

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists