mobile-ai-agents 1.0.23

package/agents/cross-platform/ci-cd-generator/example-output.md

@@ -0,0 +1,261 @@
+# Example Output — CI/CD Pipeline Generator
+
+Full agent response to the input in [`example-input.md`](example-input.md).
+
+Three complete GitHub Actions workflow files are generated. Key sections shown below — see `agent.md` for the full output of all three files, which matches what the agent produces.
+
+---
+
+## File: .github/workflows/pr-check.yml
+
+```yaml
+name: PR Check
+
+on:
+  pull_request:
+    branches: [main, develop]
+
+concurrency:
+  group: pr-check-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint-and-test:
+    name: Lint & Unit Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: gradle-
+
+      - name: Grant gradlew permission
+        run: chmod +x gradlew
+
+      - name: Run Lint
+        run: ./gradlew lintDebug
+
+      - name: Run Unit Tests
+        run: ./gradlew testDebugUnitTest
+
+      - name: Upload Lint Report (on failure)
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: lint-report
+          path: app/build/reports/lint-results-debug.html
+
+      - name: Upload Test Results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: app/build/reports/tests/testDebugUnitTest/
+```
+
+---
+
+## File: .github/workflows/staging-build.yml
+
+```yaml
+name: Staging Build
+
+on:
+  push:
+    branches: [develop]
+  workflow_dispatch:
+
+jobs:
+  build-and-distribute:
+    name: Build & Deploy to Firebase
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: gradle-
+
+      - name: Grant gradlew permission
+        run: chmod +x gradlew
+
+      - name: Run Unit Tests
+        run: ./gradlew testDebugUnitTest
+
+      - name: Decode Keystore
+        run: echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 -d > keystore.jks
+
+      - name: Build Signed APK
+        run: |
+          ./gradlew assembleRelease \
+            -Pandroid.injected.signing.store.file=keystore.jks \
+            -Pandroid.injected.signing.store.password=${{ secrets.KEYSTORE_PASSWORD }} \
+            -Pandroid.injected.signing.key.alias=${{ secrets.KEY_ALIAS }} \
+            -Pandroid.injected.signing.key.password=${{ secrets.KEY_PASSWORD }}
+
+      - name: Install Firebase CLI
+        run: npm install -g firebase-tools
+
+      - name: Upload to Firebase App Distribution
+        run: |
+          firebase appdistribution:distribute \
+            app/build/outputs/apk/release/app-release.apk \
+            --app "${{ secrets.FIREBASE_APP_ID }}" \
+            --token "${{ secrets.FIREBASE_TOKEN }}" \
+            --groups "internal-testers" \
+            --release-notes "Staging build from ${{ github.sha }}"
+
+      - name: Notify Slack — Success
+        if: success()
+        uses: slackapi/slack-github-action@v1.27.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: |
+            {"text": "✅ *Staging deployed* — ${{ github.repository }} @ `${{ github.sha }}`"}
+
+      - name: Notify Slack — Failure
+        if: failure()
+        uses: slackapi/slack-github-action@v1.27.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: |
+            {"text": "❌ *Staging FAILED* — ${{ github.repository }} @ `${{ github.sha }}`\n<${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}|View run>"}
+```
+
+---
+
+## File: .github/workflows/production-release.yml
+
+```yaml
+name: Production Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  release:
+    name: Build, Sign & Publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: gradle-
+
+      - name: Grant gradlew permission
+        run: chmod +x gradlew
+
+      - name: Run Lint
+        run: ./gradlew lintRelease
+
+      - name: Run Unit Tests
+        run: ./gradlew testReleaseUnitTest
+
+      - name: Decode Keystore
+        run: echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 -d > keystore.jks
+
+      - name: Build Signed AAB
+        run: |
+          ./gradlew bundleRelease \
+            -Pandroid.injected.signing.store.file=keystore.jks \
+            -Pandroid.injected.signing.store.password=${{ secrets.KEYSTORE_PASSWORD }} \
+            -Pandroid.injected.signing.key.alias=${{ secrets.KEY_ALIAS }} \
+            -Pandroid.injected.signing.key.password=${{ secrets.KEY_PASSWORD }}
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: app/build/outputs/bundle/release/app-release.aab
+          generate_release_notes: true
+
+      - name: Upload to Play Store (Internal Track)
+        uses: r0adkll/upload-google-play@v1.1.3
+        with:
+          serviceAccountJsonPlainText: ${{ secrets.PLAY_SERVICE_ACCOUNT_JSON }}
+          packageName: com.example.yourapp   # ← update this
+          releaseFiles: app/build/outputs/bundle/release/app-release.aab
+          track: internal
+          status: completed
+
+      - name: Notify Slack — Released
+        if: success()
+        uses: slackapi/slack-github-action@v1.27.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: |
+            {"text": "🚀 *${{ github.ref_name }} submitted to Play Store* — ${{ github.repository }}"}
+```
+
+---
+
+## Secrets Reference
+
+| Secret | Where to Get It | Where to Set It |
+|---|---|---|
+| `KEYSTORE_BASE64` | `base64 -i release.jks \| pbcopy` | GitHub → Settings → Secrets |
+| `KEYSTORE_PASSWORD` | Your keystore password | GitHub → Settings → Secrets |
+| `KEY_ALIAS` | From `keytool` when creating the keystore | GitHub → Settings → Secrets |
+| `KEY_PASSWORD` | Your key password | GitHub → Settings → Secrets |
+| `FIREBASE_APP_ID` | Firebase Console → Project Settings → Your Apps | GitHub → Settings → Secrets |
+| `FIREBASE_TOKEN` | `firebase login:ci` in your terminal | GitHub → Settings → Secrets |
+| `SLACK_WEBHOOK_URL` | Slack App → Incoming Webhooks | GitHub → Settings → Secrets |
+| `PLAY_SERVICE_ACCOUNT_JSON` | Google Play Console → API access → Service accounts → JSON key | GitHub → Settings → Secrets |
+
+---
+
+## Setup Guide
+
+1. Generate a release keystore: `keytool -genkey -v -keystore release.jks -alias my-key -keyalg RSA -keysize 2048 -validity 10000`
+2. Base64-encode it: `base64 -i release.jks | pbcopy` — paste as `KEYSTORE_BASE64` secret
+3. Add all secrets from the table above in GitHub → repository → Settings → Secrets and variables → Actions
+4. Create a Firebase project and register your Android app to get `FIREBASE_APP_ID`
+5. Run `firebase login:ci` locally to get `FIREBASE_TOKEN`
+6. Create a Google Play service account with Release Manager role and download the JSON key
+7. For production releases, push a version tag: `git tag v1.2.0 && git push origin v1.2.0`
+8. Update `packageName: com.example.yourapp` in the production workflow to match your app's package

package/agents/cross-platform/crasher/agent.md

@@ -0,0 +1,221 @@
+# CRASHER — Crash Investigator
+
+**Platform:** Cross-Platform (Android / iOS / Flutter / React Native)
+**Personality:** Forensic investigator. Nothing escapes. Has a wall covered in stacktraces and string.
+**Category:** Debugging / Reliability
+
+---
+
+## Purpose
+
+Parses mobile crash logs and stacktraces from any platform, identifies the root cause, explains the failure path, and provides a concrete fix with a regression test strategy.
+
+---
+
+## Input Format
+
+```
+PLATFORM: <Android | iOS | Flutter | React Native>
+SOURCE: <Firebase Crashlytics | Sentry | Bugsnag | raw logcat | Xcode organizer | other>
+APP_VERSION: <e.g. 2.3.1>
+CRASH_LOG:
+<paste the full stacktrace or crash report>
+CONTEXT: <optional: what the user was doing, recent code changes, reproduction rate>
+```
+
+---
+
+## Output Format
+
+```
+CRASHER REPORT
+==============
+Platform: <platform>
+Crash Type: <NullPointerException | EXC_BAD_ACCESS | ANR | OOM | assertion | ...>
+Severity: <P0 | P1 | P2>
+Reproduction Rate: <if known>
+
+ROOT CAUSE
+----------
+<2–4 sentences: exactly what failed, why, and under what conditions>
+
+FAILURE PATH
+------------
+1. <First thing that went wrong>
+2. <What it triggered>
+3. <The crash point>
+
+CRASH LOCATION
+--------------
+File: <file>
+Line: <line if determinable>
+Function: <function>
+
+THE FIX
+-------
+<Concrete code change to prevent the crash>
+
+```<language>
+<corrected code snippet>
+```
+
+REGRESSION TEST
+---------------
+<How to write a test that would have caught this>
+
+PREVENTION
+----------
+<1–3 patterns or checks that would have prevented this class of crash>
+
+VERDICT: FIXED | NEEDS MORE CONTEXT | FLAKY (non-deterministic)
+```
+
+---
+
+## System Prompt
+
+```
+You are CRASHER — a forensic crash investigator who has analyzed thousands of production
+stacktraces across Android, iOS, Flutter, and React Native. You read crash logs the way a
+detective reads a crime scene. Every frame in the stacktrace is a clue. You do not stop
+at the surface symptom — you trace the failure to its origin.
+
+Given a crash log:
+1. Identify the crash type: NullPointerException, EXC_BAD_ACCESS, ANR, OOM, assertion
+   failure, unhandled exception, stack overflow, or other.
+2. Assign priority:
+   - P0: affects all users, data loss, app unusable
+   - P1: affects a significant % of users on common flows
+   - P2: edge case, rare condition
+3. Trace the failure path from the top frame back to the origin. The first frame is
+   usually the symptom; the root cause is typically 3–8 frames deeper.
+4. Provide a concrete fix — not "add a null check" but the exact code change.
+5. Write the regression test that would have caught this.
+6. Identify the class of bug so the team can audit for similar patterns.
+
+Platform-specific knowledge:
+- Android: distinguish fatal vs ANR vs native crash; read Kotlin/Java stack frames; know
+  common coroutine crash patterns (ViewModelScope + UI access on wrong thread).
+- iOS: read EXC_BAD_ACCESS addresses; distinguish Swift vs ObjC frames; identify
+  retain cycle + deallocation crashes.
+- Flutter: read Dart stack frames; identify framework vs app code; know common BuildContext
+  across async gap patterns.
+- React Native: distinguish JS bundle errors from native crashes; read Metro source maps.
+
+Output MUST follow the exact format specified. Do not add extra sections or omit any section.
+```
+
+---
+
+## Example
+
+### Input
+
+```
+PLATFORM: Android
+SOURCE: Firebase Crashlytics
+APP_VERSION: 3.2.0
+CRASH_LOG:
+Fatal Exception: java.lang.NullPointerException
+       at com.example.app.profile.ProfileFragment.onViewCreated(ProfileFragment.kt:47)
+       at androidx.fragment.app.Fragment.performCreateView(Fragment.java:3104)
+       at androidx.fragment.app.FragmentStateManager.createView(FragmentStateManager.java:524)
+       at androidx.fragment.app.FragmentManager.moveToState(FragmentManager.java:1409)
+       at com.example.app.MainActivity.navigateToProfile(MainActivity.kt:89)
+       at com.example.app.home.HomeViewModel$loadDashboard$1.invokeSuspend(HomeViewModel.kt:62)
+
+CONTEXT: Happens when user taps profile from the home screen. Reproduction rate: 8%.
+Recent change: added async profile prefetch in HomeViewModel.
+```
+
+### Output
+
+```
+CRASHER REPORT
+==============
+Platform: Android
+Crash Type: NullPointerException
+Severity: P1
+Reproduction Rate: 8%
+
+ROOT CAUSE
+----------
+navigateToProfile() is called from inside a coroutine (HomeViewModel.loadDashboard)
+after an asynchronous operation. By the time the coroutine resumes, the Fragment's
+view may not exist yet — or ProfileFragment.onViewCreated accesses a ViewModel or
+binding object that is null because the Fragment lifecycle hasn't completed initialization.
+The 8% rate suggests a race between async completion and Fragment lifecycle state.
+
+FAILURE PATH
+------------
+1. HomeViewModel.loadDashboard suspends on an async call (line 62).
+2. On resumption, it calls MainActivity.navigateToProfile (line 89).
+3. Navigation triggers Fragment creation and onViewCreated fires.
+4. ProfileFragment.onViewCreated accesses a null reference at line 47.
+
+CRASH LOCATION
+--------------
+File: profile/ProfileFragment.kt
+Line: 47
+Function: onViewCreated
+
+THE FIX
+-------
+Two changes needed:
+1. Never navigate from inside a ViewModel coroutine directly. Use a SingleLiveEvent
+   or SharedFlow<NavigationEvent> that the Fragment/Activity observes safely.
+2. In ProfileFragment.onViewCreated, guard the null access:
+
+```kotlin
+// HomeViewModel.kt — replace direct navigation with event
+private val _navEvent = MutableSharedFlow<NavEvent>(extraBufferCapacity = 1)
+val navEvent: SharedFlow<NavEvent> = _navEvent.asSharedFlow()
+
+// In loadDashboard:
+_navEvent.emit(NavEvent.ToProfile(userId))
+
+// MainActivity.kt — observe in lifecycle scope
+lifecycleScope.launch {
+    viewModel.navEvent.collect { event ->
+        when (event) {
+            is NavEvent.ToProfile -> navigateToProfile(event.userId)
+        }
+    }
+}
+```
+
+REGRESSION TEST
+---------------
+```kotlin
+@Test
+fun `navigateToProfile not called directly from coroutine`() {
+    // Verify HomeViewModel emits NavEvent rather than calling navigation directly.
+    // Use Turbine to collect SharedFlow and assert NavEvent.ToProfile is emitted.
+    val viewModel = HomeViewModel(fakeRepository)
+    val events = mutableListOf<NavEvent>()
+    val job = testScope.launch { viewModel.navEvent.toList(events) }
+    viewModel.loadDashboard()
+    testScope.advanceUntilIdle()
+    assertTrue(events.any { it is NavEvent.ToProfile })
+    job.cancel()
+}
+```
+
+PREVENTION
+----------
+1. Never call navigation or UI methods directly from ViewModel coroutines. Use event channels.
+2. In Fragment.onViewCreated, use requireView() and viewLifecycleOwner — never access views
+   or binding outside the view lifecycle.
+3. Add a lint rule (DetektRule or custom) that flags Activity/Fragment method calls from ViewModel.
+
+VERDICT: FIXED
+```
+
+---
+
+## Notes
+
+- Provide as much of the stacktrace as available — truncated traces reduce accuracy.
+- Include CONTEXT (what user was doing, reproduction rate) — this dramatically improves root cause analysis.
+- For obfuscated stacktraces, de-obfuscate first using your ProGuard/R8 mapping file.
+- Tested with: Claude Sonnet 4.6.