mobile-ai-agents 1.0.23

package/skills/android/android-tdd.md

@@ -0,0 +1,89 @@
+# Skill — /android-tdd
+
+**Platform:** Android (Kotlin)
+**Slash Command:** `/android-tdd`
+**Composable With:** agents/android/axiom/agent.md
+
+---
+
+## Purpose
+
+Runs the red-green-refactor TDD loop for Android — JUnit5 unit tests, Compose UI tests, and ViewModel tests with Turbine for StateFlow. Generates a failing test first, then the minimal implementation that makes it pass.
+
+---
+
+## Skill Prompt
+
+```
+Run the Android TDD loop for the described feature or function:
+
+STEP 1 — RED: Write a failing test first.
+- For business logic: JUnit5 test class using @Test, @BeforeEach, MockK or Mockito.
+- For ViewModel: use TestCoroutineDispatcher + Turbine to test StateFlow emissions.
+- For Compose UI: use ComposeTestRule + semantic matchers (onNodeWithText, performClick).
+- Test must fail for the right reason (not compile error, but assertion failure).
+
+STEP 2 — GREEN: Write the minimal implementation to make the test pass.
+- No extra logic, no future-proofing. Just enough to pass the test.
+
+STEP 3 — REFACTOR: Clean up without breaking the test.
+- Extract functions, improve naming, add sealed class if needed.
+
+Format each step clearly:
+--- RED (failing test) ---
+<test code>
+
+--- GREEN (implementation) ---
+<minimal production code>
+
+--- REFACTOR (cleaned up) ---
+<final production code>
+```
+
+---
+
+## Example
+
+**Input:** "TDD a CalculateDiscountUseCase that applies 20% off when total > 100"
+
+**Output:**
+```kotlin
+--- RED (failing test) ---
+class CalculateDiscountUseCaseTest {
+    private val useCase = CalculateDiscountUseCase()
+
+    @Test
+    fun `applies 20 percent discount when total exceeds 100`() {
+        val result = useCase(120.0)
+        assertEquals(96.0, result, 0.01)
+    }
+
+    @Test
+    fun `no discount when total is 100 or less`() {
+        val result = useCase(100.0)
+        assertEquals(100.0, result, 0.01)
+    }
+}
+
+--- GREEN (implementation) ---
+class CalculateDiscountUseCase {
+    operator fun invoke(total: Double): Double =
+        if (total > 100.0) total * 0.80 else total
+}
+
+--- REFACTOR ---
+private const val DISCOUNT_THRESHOLD = 100.0
+private const val DISCOUNT_RATE = 0.80
+
+class CalculateDiscountUseCase {
+    operator fun invoke(total: Double): Double =
+        if (total > DISCOUNT_THRESHOLD) total * DISCOUNT_RATE else total
+}
+```
+
+---
+
+## Notes
+
+- Always write the test before asking for the implementation.
+- For coroutine-heavy code, add `@OptIn(ExperimentalCoroutinesApi::class)` and use `runTest`.

package/skills/android/anr-investigation.md

@@ -0,0 +1,251 @@
+# Skill — /anr-investigation
+
+**Platform:** Android  
+**Slash Command:** `/anr-investigation`  
+**Composable With:** Android Crash Analyzer, AXIOM, PERF, MOBILE-HARNESS
+
+---
+
+## Purpose
+
+Investigate Android ANRs from Play Console, Firebase Crashlytics, `traces.txt`, `/data/anr/anr_*`, `ApplicationExitInfo`, bug reports, or source code. Identify the unresponsive thread, blocking dependency, root cause, safe fix, and verification plan.
+
+This skill is evidence-first. Do not blame the top app frame without checking thread state, locks, binder calls, and owner threads.
+
+---
+
+## Input Format
+
+```text
+COMMAND: /anr-investigation
+APP_VERSION: <version/build>
+ANDROID_VERSION: <version or unknown>
+DEVICE: <model or unknown>
+ANR_SOURCE: <Play Console | Crashlytics | traces.txt | bugreport | ApplicationExitInfo>
+ANR_REASON:
+<reason, cluster title, or timeout message>
+USER_ACTION:
+<what the user was doing>
+TRACE:
+<full ANR trace or all available thread stacks>
+RELATED_CODE:
+<relevant Activity, ViewModel, repository, service, receiver, worker, or database code>
+```
+
+---
+
+## Skill Prompt
+
+````text
+Investigate the Android ANR using the supplied evidence.
+
+STEP 1 — VERIFY EVIDENCE
+- Confirm whether the full trace and ANR reason are present.
+- Require the main thread plus any thread that may own a lock or binder response.
+- If only one frame or a partial trace is available, mark confidence LOW and list the missing evidence.
+- Do not invent line numbers, locks, timing, or thread ownership.
+
+STEP 2 — CLASSIFY THE ANR
+Classify as one of:
+- Input dispatch timeout
+- Service execution timeout
+- Foreground service start timeout
+- BroadcastReceiver timeout
+- JobService timeout
+- Main-thread I/O or computation
+- Binder stall
+- Lock contention
+- Deadlock
+- Slow startup
+- Unknown
+
+STEP 3 — READ THREAD STATES
+- Locate the "main" thread and record RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, or NATIVE.
+- RUNNABLE: inspect expensive computation, disk/network/database I/O, class loading, Compose/layout work, or synchronous SDK initialization.
+- BLOCKED: identify the monitor/lock and find the owning thread.
+- WAITING: identify Future.get, CountDownLatch.await, join, runBlocking, wait, semaphore, mutex, or synchronous callback.
+- NATIVE: inspect binder, file, database, graphics, or native SDK frames.
+- For deadlocks, show the complete wait-for cycle.
+
+STEP 4 — CORRELATE WITH CODE
+Check for:
+- Disk, Room/SQLite, SharedPreferences commit, file, JSON, bitmap, crypto, or network work on main.
+- runBlocking, Future.get, Thread.join, CountDownLatch.await, synchronized, locks, semaphores, or blocking callbacks.
+- Slow Application/ContentProvider/Activity startup and eager dependency initialization.
+- BroadcastReceiver.onReceive doing long work or goAsync without PendingResult.finish.
+- Service lifecycle methods doing blocking work.
+- startForegroundService without startForeground within the required window.
+- JobService callbacks blocking instead of returning quickly.
+- Synchronous binder calls or third-party SDK initialization.
+- Compose recomposition/layout loops only when trace evidence supports them.
+
+STEP 5 — PROPOSE THE SMALLEST SAFE FIX
+- Fix the proven blocking path, not merely the top stack frame.
+- Use structured coroutines and appropriate dispatchers, but do not wrap unknown code in Dispatchers.IO blindly.
+- Avoid replacing one ANR with lost work, races, lifecycle leaks, or unbounded background work.
+- Use WorkManager for deferrable persistent work; keep receiver/service/job callbacks short.
+- Reduce lock scope or redesign ownership for contention/deadlock.
+- Provide before/after Kotlin when source is available.
+
+STEP 6 — VERIFY
+Include:
+- Deterministic reproduction steps.
+- StrictMode or tracing setup where relevant.
+- Low-end device and cold-start testing.
+- Macrobenchmark/startup measurement where relevant.
+- Regression test or test seam.
+- Play Console ANR cluster and user-perceived ANR monitoring.
+
+Output normal Markdown. Do not wrap the full report in a code block.
+
+ANDROID ANR INVESTIGATION
+=========================
+Result: CONFIRMED | LIKELY | INCONCLUSIVE
+Confidence: HIGH | MEDIUM | LOW
+ANR Type:
+Trigger:
+
+Evidence Summary:
+| Evidence | Observation |
+|---|---|
+
+Thread Analysis:
+| Thread | State | Waiting On / Work | Significance |
+|---|---|---|---|
+
+Root Cause:
+<proven causal chain, or what remains unknown>
+
+Fix:
+<smallest safe fix>
+
+Updated Code:
+```kotlin
+<corrected code, or "Not available without related source">
+```
+
+Verification:
+- <step>
+
+Missing Evidence:
+- <item or "None">
+
+Next Action:
+<one concrete action>
+````
+
+---
+
+## Example
+
+### Input
+
+```text
+COMMAND: /anr-investigation
+APP_VERSION: 4.8.0 (480)
+ANDROID_VERSION: 14
+DEVICE: Pixel 6a
+ANR_SOURCE: Play Console
+ANR_REASON:
+Input dispatching timed out
+USER_ACTION:
+Cold launch, then tapped Sign in.
+TRACE:
+"main" prio=5 tid=1 Blocked
+  at com.example.session.SessionStore.read(SessionStore.kt:42)
+  - waiting to lock <0x1234> held by thread 18
+  at com.example.MainActivity.onCreate(MainActivity.kt:31)
+
+"DefaultDispatcher-worker-3" prio=5 tid=18 Runnable
+  at com.example.session.SessionStore.refresh(SessionStore.kt:68)
+  - locked <0x1234>
+  at com.example.session.SessionRepository.refresh(SessionRepository.kt:51)
+RELATED_CODE:
+class SessionStore {
+    @Synchronized
+    fun read(): Session? = cachedSession
+
+    @Synchronized
+    fun refresh(): Session {
+        val response = blockingApi.refreshToken()
+        return response.toSession().also { cachedSession = it }
+    }
+}
+```
+
+### Output
+
+````markdown
+ANDROID ANR INVESTIGATION
+=========================
+Result: CONFIRMED
+Confidence: HIGH
+ANR Type: Lock contention causing input dispatch timeout
+Trigger: Cold launch while token refresh holds SessionStore monitor
+
+Evidence Summary:
+| Evidence | Observation |
+|---|---|
+| Main thread | BLOCKED in SessionStore.read |
+| Monitor | `0x1234`, owned by thread 18 |
+| Owner thread | Performs blocking token refresh |
+| Timeout reason | Input dispatching timed out |
+
+Thread Analysis:
+| Thread | State | Waiting On / Work | Significance |
+|---|---|---|---|
+| main | BLOCKED | SessionStore monitor | Cannot process input |
+| worker-3 | RUNNABLE | Blocking network refresh | Holds required monitor |
+
+Root Cause:
+`SessionStore.refresh()` holds the object monitor during a blocking network request. `MainActivity.onCreate()` calls `read()`, which requires the same monitor. The main thread remains blocked until the network request returns, causing the input timeout.
+
+Fix:
+Do not hold the session lock during network I/O. Perform refresh outside the critical section and lock only the in-memory assignment. Expose session reads without waiting on network work.
+
+Updated Code:
+```kotlin
+class SessionStore(
+    private val api: SessionApi,
+) {
+    @Volatile
+    private var cachedSession: Session? = null
+
+    fun read(): Session? = cachedSession
+
+    suspend fun refresh(): Session {
+        val refreshed = withContext(Dispatchers.IO) {
+            api.refreshToken().toSession()
+        }
+        cachedSession = refreshed
+        return refreshed
+    }
+}
+```
+
+Verification:
+- Reproduce cold launch while delaying refresh by 10 seconds.
+- Enable StrictMode and confirm no main-thread network/disk violations.
+- Capture a system trace and verify main remains runnable.
+- Repeat launch and sign-in on a low-end Android device.
+- Monitor the Play Console ANR cluster after staged rollout.
+
+Missing Evidence:
+- None
+
+Next Action:
+Remove network I/O from the SessionStore monitor, then rerun the delayed-refresh cold-launch test.
+````
+
+---
+
+## Usage Notes
+
+- A full thread dump is required for high-confidence lock and deadlock analysis.
+- The main thread's top frame can be a victim rather than the cause; always inspect the thread holding its dependency.
+- Pair with PERF for startup/system-trace work and Android Crash Analyzer for broader incident triage.
+- This skill supports issue #2; a dedicated ANR agent can embed it and add expanded examples.
+
+## Official Reference
+
+- [Android Developers: ANRs](https://developer.android.com/topic/performance/vitals/anr)

package/skills/android/code-review.md

@@ -0,0 +1,98 @@
+# Skill — Android Code Review
+
+**Platform:** Android (Kotlin)  
+**Category:** Code Quality  
+**Composable With:** agents/android/code-reviewer/agent.md, skills/shared/clean-architecture-check.md
+
+---
+
+## Purpose
+
+Adds Android-specific code review rules to any LLM session. Use this as a skill module to prime a review session without running the full agent.
+
+## When to Use
+
+- When you want a quick inline review during a pair-programming session
+- When composing a larger review workflow that covers multiple files
+- When you want only Android-specific checks without the full structured output format
+
+---
+
+## Skill Prompt
+
+```
+When reviewing Android Kotlin code, check for these issues:
+
+COROUTINE SAFETY
+- Never use GlobalScope. Use viewModelScope (in ViewModel), lifecycleScope (in Activity/Fragment), or a custom CoroutineScope with a Job that is cancelled appropriately.
+- Coroutines that call suspend functions should handle exceptions with try/catch or a CoroutineExceptionHandler. Fire-and-forget coroutines that swallow exceptions are bugs waiting to happen.
+- UI state updates (LiveData.value, StateFlow updates) must happen on the Main dispatcher.
+
+KOTLIN IDIOMS
+- Prefer data class for value-holding types.
+- Prefer sealed class for state/result types over Boolean flags or nullable + exception patterns.
+- Prefer StateFlow + collectAsStateWithLifecycle over LiveData in new code.
+- Use `?.let`, `?.run`, `?:` for null safety. Flag every `!!` operator as a candidate for removal.
+- Prefer `when` expressions over chains of if/else.
+
+DEPENDENCY INJECTION
+- No `new MyRepository()` inside a ViewModel or Fragment. Dependencies must be injected (Hilt, Koin, manual constructor injection).
+- No singletons held as companion object properties for testability-sensitive objects.
+
+CLEAN ARCHITECTURE
+- Domain layer (use cases, entities): zero Android framework imports.
+- Data layer (repositories, data sources): no UI-level types, no Context except for file/preference access.
+- Presentation layer (ViewModel): no database calls directly, no network calls directly — only use cases.
+
+COMPOSE (if applicable)
+- Side effects belong in LaunchedEffect, not in composable bodies.
+- Expensive calculations belong in remember { } or derivedStateOf { }.
+- Avoid reading mutableStateOf values outside of composition.
+- collectAsStateWithLifecycle is preferred over collectAsState for lifecycle awareness.
+
+For each issue found, state: the line or function, what is wrong, and a concrete fix.
+```
+
+---
+
+## Example
+
+**Input (after applying skill prompt):**
+```
+Review this ViewModel:
+
+class OrderViewModel : ViewModel() {
+    fun placeOrder(items: List<Item>) {
+        GlobalScope.launch {
+            OrderRepository().submit(items)
+        }
+    }
+}
+```
+
+**Output:**
+```
+Line 3 — GlobalScope leak: Replace with viewModelScope.launch { ... }
+Line 4 — Direct repository instantiation: Inject OrderRepository via constructor.
+No error handling: If submit() throws, the exception is silently dropped.
+Suggestion: Wrap in try/catch and expose error state via a StateFlow<OrderState>.
+```
+
+---
+
+## Composition Example
+
+```
+Prepend this skill prompt before the Android Code Reviewer system prompt to add
+a focused lens on coroutines and Compose alongside the full structured review output.
+
+Or use standalone in a Claude Code chat session — paste this skill, then paste
+your Kotlin file and ask "Review this for the issues listed above."
+```
+
+---
+
+## Notes
+
+- This skill covers Kotlin only. For Java Android code, the coroutine rules do not apply but the DI and Clean Architecture rules still hold.
+- Compose checks require Compose to be in use — skip those rules for View-based UIs.

package/skills/android/compose-migration.md

@@ -0,0 +1,48 @@
+# Skill — /compose-migration
+
+**Platform:** Android
+**Slash Command:** `/compose-migration`
+
+---
+
+## Purpose
+
+Systematically converts Android XML layouts to Jetpack Compose. Handles ConstraintLayout, RecyclerView, ViewPager2, and custom views. Produces idiomatic Compose code with proper state lifting.
+
+---
+
+## Skill Prompt
+
+```
+Migrate the provided Android XML layout (or View-based code) to Jetpack Compose:
+
+MIGRATION RULES:
+1. Layout mapping:
+   - LinearLayout (vertical) → Column
+   - LinearLayout (horizontal) → Row
+   - FrameLayout / merge → Box
+   - ConstraintLayout → ConstraintLayout (Compose) or restructured Column/Row/Box
+   - ScrollView → Column inside verticalScroll(rememberScrollState())
+   - RecyclerView → LazyColumn / LazyRow with items(key = { ... })
+   - ViewPager2 → HorizontalPager (Accompanist/Foundation)
+
+2. Attribute mapping:
+   - android:layout_width="match_parent" → Modifier.fillMaxWidth()
+   - android:layout_width="wrap_content" → default (no modifier needed)
+   - android:padding → Modifier.padding()
+   - android:gravity / layout_gravity → Arrangement + Alignment
+   - android:visibility → if (condition) { Composable() }
+   - android:background → Modifier.background()
+   - android:textSize / textColor / fontStyle → TextStyle or MaterialTheme.typography
+
+3. State lifting:
+   - View state (setVisibility, setText) → hoist to ViewModel StateFlow
+   - ClickListeners → lambda parameters on the composable
+   - TextWatcher → onValueChange with mutableStateOf
+
+4. Custom views:
+   - AndroidView { } wrapper for views with no Compose equivalent
+   - Migrate incrementally — keep complex custom views as AndroidView until full migration
+
+Output the complete Compose equivalent. Note any migration challenges or manual steps needed.
+```

package/skills/android/compose-review.md

@@ -0,0 +1,78 @@
+# Skill — /compose-review
+
+**Platform:** Android (Jetpack Compose)
+**Slash Command:** `/compose-review`
+**Composable With:** agents/android/axiom/agent.md
+
+---
+
+## Purpose
+
+Recomposition audit for Jetpack Compose files. Flags unnecessary recompositions, incorrect state usage, missing `const` constructors, and lambda instability before PR merge.
+
+---
+
+## Skill Prompt
+
+```
+Audit the provided Jetpack Compose code for recomposition issues:
+
+1. UNNECESSARY RECOMPOSITIONS
+   - Lambdas passed as parameters that are recreated every composition.
+     Fix: wrap in remember { } or move to ViewModel.
+   - Objects created inline in composable bodies (val list = listOf(...) inside Composable).
+     Fix: hoist to remember { } or to the ViewModel.
+   - Reading State inside a composable that also writes it (causes infinite recomposition).
+
+2. STATE USAGE
+   - remember vs rememberSaveable: use rememberSaveable for state that survives config changes.
+   - derivedStateOf: use when computing a value that depends on other state to minimize recompositions.
+   - collectAsStateWithLifecycle: always prefer over collectAsState for lifecycle safety.
+   - mutableStateListOf / mutableStateMapOf: flag direct mutations that don't trigger recomposition.
+
+3. COMPOSITION KEYS
+   - LazyList items missing key parameter → unnecessary recomposition on list changes.
+   - key { } block containing a mutable value that changes without semantic identity change.
+
+4. SIDE EFFECTS
+   - Bare code in composable body that has side effects (file I/O, network, logging).
+     Fix: wrap in SideEffect, LaunchedEffect, or DisposableEffect as appropriate.
+   - LaunchedEffect with Unit key that should restart on specific input changes.
+
+5. PERFORMANCE
+   - Composables that could be @Stable or marked as stable data classes.
+   - Heavy computations not wrapped in remember { } with appropriate keys.
+
+For each issue: state the composable name, line (if given), what triggers the recomposition, and the fix.
+```
+
+---
+
+## Example
+
+**Input:**
+```kotlin
+@Composable
+fun UserList(users: List<User>) {
+    val filtered = users.filter { it.isActive }
+    LazyColumn {
+        items(filtered) { user ->
+            UserRow(user = user, onClick = { navigateToProfile(user.id) })
+        }
+    }
+}
+```
+
+**Output:**
+```
+Line 3 — List filtered in composable body
+  Every recomposition re-runs users.filter { } creating a new list.
+  Fix: val filtered = remember(users) { users.filter { it.isActive } }
+
+LazyColumn items — missing key parameter
+  Without key, LazyColumn re-renders ALL items when the list changes.
+  Fix: items(filtered, key = { it.id }) { user -> ... }
+
+Line 4 — Lambda { navigateToProfile(user.id) } recreated per item per recomposition
+  Fix: val onUserClick = remember(user.id) { { navigateToProfile(user.id) } }
+```

package/skills/android/kotlin-modernize.md

@@ -0,0 +1,51 @@
+# Skill — /kotlin-modernize
+
+**Platform:** Android (Kotlin)
+**Slash Command:** `/kotlin-modernize`
+
+---
+
+## Purpose
+
+Upgrades Java-style Kotlin or pre-2.0 Kotlin code to modern Kotlin idioms. Converts verbose patterns to concise equivalents, introduces sealed classes, coroutines, and Flow where appropriate.
+
+---
+
+## Skill Prompt
+
+```
+Modernize the provided Kotlin code using current idiomatic patterns:
+
+KOTLIN MODERNIZATION CHECKLIST:
+1. Null safety:
+   - Replace `if (x != null)` with `x?.let { }` or `x ?: default`
+   - Remove all `!!` operators — replace with safe call + Elvis or requireNotNull with message
+   - Replace nullable + isInitialized patterns with lateinit + try/catch or by lazy { }
+
+2. Data structures:
+   - Java-style Builder pattern → named parameters + default values
+   - Value objects with equals/hashCode → data class
+   - Enum with methods → sealed class with data objects/data classes
+
+3. Collections:
+   - Imperative loops → map, filter, flatMap, fold, groupBy, associate
+   - Mutable collections passed as function params → immutable + return new list
+   - Java stream() → Kotlin collection functions (simpler, no stream overhead on Android)
+
+4. Coroutines (if async code present):
+   - Callback hell → suspend functions + coroutines
+   - AsyncTask → viewModelScope.launch + suspend function
+   - RxJava (if present) → Flow equivalents: Observable → Flow, Single → suspend fun
+
+5. Scope functions:
+   - Multi-line null checks → let
+   - Object initialization chains → apply or also
+   - Result transformation → run or with
+
+6. String handling:
+   - String concatenation in loops → buildString { }
+   - Format strings → string templates
+   - Multi-line strings → trimIndent() triple-quoted strings
+
+Show before and after for each significant transformation.
+```