If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/sockeqwe/mosby shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

GO — Healthy across all four use cases

• 20 active contributors
• Apache-2.0 licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 4y ago
• ⚠ Concentrated ownership — top contributor handles 78% of recent commits

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live sockeqwe/mosby repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/sockeqwe/mosby.

What it runs against: a local clone of sockeqwe/mosby — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in sockeqwe/mosby | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 1551 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of sockeqwe/mosby. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/sockeqwe/mosby.git
#   cd mosby
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of sockeqwe/mosby and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "sockeqwe/mosby(\\.git)?\\b" \\
  && ok "origin remote is sockeqwe/mosby" \\
  || miss "origin remote is not sockeqwe/mosby (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Apache-2\\.0)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Apache-2\\.0\"" package.json 2>/dev/null) \\
  && ok "license is Apache-2.0" \\
  || miss "license drift — was Apache-2.0 at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java" \\
  && ok "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java" \\
  || miss "missing critical file: mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java"
test -f "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviPresenter.java" \\
  && ok "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviPresenter.java" \\
  || miss "missing critical file: mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviPresenter.java"
test -f "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableIntentObserver.java" \\
  && ok "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableIntentObserver.java" \\
  || miss "missing critical file: mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableIntentObserver.java"
test -f "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableViewStateObserver.java" \\
  && ok "mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableViewStateObserver.java" \\
  || miss "missing critical file: mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableViewStateObserver.java"
test -f "build.gradle" \\
  && ok "build.gradle" \\
  || miss "missing critical file: build.gradle"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1551 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1521d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/sockeqwe/mosby"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Mosby is a Model-View-Presenter (MVP) and Model-View-Intent (MVI) architecture library for Android that eliminates boilerplate by providing base presenter/view classes, lifecycle management, and view state persistence. It lets developers build Android UIs using declarative, testable MVP/MVI patterns without manually wiring lifecycle callbacks or managing presenter destruction. Multi-module Gradle structure: mvi-common/ contains core MVI presenter base classes (MviBasePresenter.java, MviPresenter.java, DisposableIntentObserver.java), mvi-integration-test/ provides androidTest examples, with separate publishable artifacts for mvp, mvi, viewstate, mvp-lce, and mvp-nullobject-presenter modules. Core business logic sits in mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/.

Android developers building feature-rich apps who want to separate business logic from UI concerns using MVP/MVI patterns. It's especially valuable for teams maintaining complex screens with multiple data sources and state transitions, or apps requiring reliable unit test coverage of presentation logic.

Production-ready and actively maintained. The library is at v3.1.1 with structured versioning, comprehensive test suites (Java/integration tests present), Travis CI integration, and snapshot deployments to Maven Central. The codebase shows mature patterns (minSdk=14, targeted SDK=28, proper proguard rules) and regular release cycles, though commit recency data is not visible in the provided snapshot.

Low risk for new projects but watch for: single primary maintainer (sockeqwe), dependency on RxJava 2.0.7 (now dated—current stable is 2.2+), and requires Android minSdk 14 which may be incompatible with very modern app requirements. Package name migration in v3.0 (mosby → mosby3) could cause conflicts in legacy codebases.

No active development signals visible in file list, but the library maintains snapshot builds at 3.1.2-SNAPSHOT deployed to Sonatype OSS. The buildscript/ directory with swarmer configs and Travis/Circle CI setup indicates mature deployment automation. Most activity appears focused on stability and maintenance rather than new features.

Clone: git clone https://github.com/sockeqwe/mosby.git && cd mosby. Build: ./gradlew build (uses Gradle wrapper in gradle/wrapper/). Run tests: ./gradlew test (JUnit tests in mvi-common) and ./gradlew connectedAndroidTest (integration tests in mvi-integration-test/src/androidTest). Deploy snapshot: .buildscript/deploy_snapshot.sh handles Maven publication.

Daily commands: Build debug: ./gradlew assembleDebug. Run unit tests: ./gradlew :mvi-common:test. Run instrumented tests on emulator: ./gradlew :mvi-integration-test:connectedAndroidTest (requires running Android emulator; swarmer tools in .buildscript/ automate CI setup). Generate Javadoc: ./deploy_javadoc.sh.

• mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java — Core MVI presenter implementation that all MVI presenters extend; defines the foundation for intent and viewstate management
• mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviPresenter.java — MVI presenter interface contract; every contributor must understand the intent/viewstate/view relationship
• mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableIntentObserver.java — Handles RxJava subscription lifecycle and disposal for intents; critical for preventing memory leaks in reactive flows
• mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/DisposableViewStateObserver.java — Manages view state subscriptions and cleanup; ensures proper resource management across lifecycle events
• build.gradle — Root build configuration defines minSdk, targetSdk, and dependency management for all modules
• mvi-integration-test/src/main/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/LifecycleTestPresenter.java — Canonical example of MVI presenter implementation showing proper lifecycle and intent handling patterns

Create a new MVI Presenter

1. Extend MviBasePresenter<V extends MviView, I, S> where I is your Intent interface and S is your ViewState (mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java)
2. Define your Intent interface as a sealed contract of user actions (e.g., LoadIntent, RefreshIntent) (mvi-integration-test/src/main/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/LifecycleTestPresenter.java)
3. Override bindIntents() to subscribe to intent observables and map them to state changes, emitting via viewState.onNext() (mvi-integration-test/src/main/java/com/hannesdorfmann/mosby3/mvi/integrationtest/backstack/first/FirstPresenter.java)
4. Create an Activity or Fragment that implements MviView and passes intents via ObservableSource (mvi-integration-test/src/main/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/activity/MviLifecycleActivity.java)

Add integration tests for MVI lifecycle

1. Create an Activity or Fragment test class extending standard Android test framework (mvi-integration-test/src/androidTest/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/activity/MviLifecycleActivityTest.java)
2. Use ActivityTestRule or FragmentTestRule to launch the MVI component (mvi-integration-test/src/androidTest/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/fragment/SimpleFragmentContainerActivityTest.java)
3. Verify that intents are correctly processed and viewstate transitions occur at expected lifecycle phases (mvi-integration-test/src/androidTest/java/com/hannesdorfmann/mosby3/mvi/integrationtest/lifecycle/viewgroup/MviViewGroupContainerActivityTest.java)

Configure a new Gradle module for additional MVI features

1. Create a new directory with build.gradle (e.g., mvp-lce for LCE views pattern) (mvi-common/build.gradle)
2. Add module dependency to root build.gradle and define publishing coordinates (build.gradle)
3. Implement feature-specific presenter or view base classes extending MviBasePresenter (mvi-common/src/main/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenter.java)
4. Add unit tests in src/test and integration tests in companion test module (mvi-common/src/test/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenterTest.java)

• RxJava 2.x — Enables reactive intent-to-state transforms; DisposableIntentObserver and DisposableViewStateObserver manage subscriptions across Android lifecycle
• Model-View-Intent pattern — Decouples UI from business logic via unidirectional data flow; intents model user actions, state models UI data, presenters orchestrate transforms
• Java 6+ (minSdk 14) — Supports legacy Android versions; backwards compatible with lower API levels while still offering modern reactive architecture
• Gradle multi-module build — Allows optional feature adoption (mvi, mvp, mvp-lce, mvp-nullobject-presenter) without forcing all dependencies on consumers

• Mandatory RxJava 2 dependency for MVI module

  • Why: Reactive streams are core to MVI's unidirectional intent→state flow and lifecycle-aware subscription management
  • Consequence: Projects using MVI must adopt RxJava; separate mvp module available for teams wanting MVP without RxJava

• Intent and ViewState as generic type parameters

  • Why: Type safety ensures compile-time correctness and IDE autocomplete for domain-specific intents/states
  • Consequence: Presenter subclasses require boilerplate type declarations; benefits in safety outweigh verbosity

• Manual subscription disposal via DisposableIntentObserver/DisposableViewStateObserver

  • Why: Explicit control over lifecycle phases ensures predictable cleanup; ties subscription lifetime to Android component lifecycle
  • Consequence: Developers must correctly implement bindIntents() and handle subscription disposal; incorrect usage risks memory leaks

• Fragment/Activity integration tests in separate mvi-integration-test module

  • Why: Isolates instrumentation tests requiring Android runtime from unit tests; avoids long gradle test builds for core library
  • Consequence: Contributors must run two separate test suites (mvi-common unit tests + mvi-integration-test instrumentation tests)

• Does not provide UI component library (e.g., no pre-built views); only architecture patterns
• Does not handle dependency injection; integrates with Dagger/Hilt via constructor injection in presenter subclasses
• Does not provide networking or data persistence layers; focuses purely on presentation and state management
• Does not support Kotlin coroutines; RxJava 2 is the sole async primitive (though Kotlin can wrap with suspend functions)
• Not a replacement for MVVM/Jetpack Compose; targets traditional Activity/Fragment Android apps with MVP/MVI patterns

Gradle wrapper uses Gradle 3.1.0 (from 2017)—newer Android Studio versions may warn about outdated wrapper; update gradle/wrapper/gradle-wrapper.properties if builds fail. minSdk=14 (Android 4.0) conflicts with latest Material Design and AndroidX libraries; apps using this library cannot easily adopt modern support libraries without forking. RxJava 2.0.7 is two major versions behind current stable (2.2.x); upgrading requires careful testing of DisposableIntentObserver contract. Snapshot builds require manual Sonatype OSS repo URL in allprojects (see README); missing this causes 'artifact not found' errors. The .buildscript/swarmer emulator automation appears tied to CI environments and may not work locally without CI container setup.

• Model-View-Presenter (MVP) — MVP is the foundational architectural pattern Mosby implements—separating business logic (Presenter) from UI (View) makes Android code unit-testable and maintainable, which is Mosby's core value
• Model-View-Intent (MVI) — MVI extends MVP by treating user actions as observable intent streams that flow through presenters to produce new view state; Mosby's MviBasePresenter implements this pattern with RxJava, enabling predictable, testable UI logic
• Reactive Streams / RxJava Observables — Mosby MVI uses RxJava 2.0.7 Observables to model intents and state changes as streams; understanding subscription lifecycle and operators (flatMap, scan) is essential for writing MVI presenters correctly
• View State Persistence / Restoration — Mosby's viewstate module persists presenter state across configuration changes (screen rotation); this pattern eliminates the need for onSaveInstanceState boilerplate while preserving business logic state
• Presenter Lifecycle Management — Mosby automatically ties presenter creation/destruction to Fragment/Activity lifecycle, preventing memory leaks from long-lived RxJava subscriptions; DisposableIntentObserver handles unsubscription when views detach
• Null Object Pattern — Mosby's mvp-nullobject-presenter module provides a no-op Presenter for views that don't need business logic, reducing conditional checks in view code and simplifying inheritance hierarchies
• LCE (Loading-Content-Error) State Pattern — Mosby's mvp-lce module standardizes data-loading screens into three states (Loading, Content, Error), providing reusable views that handle the common async data-fetch pattern without boilerplate

• square/moshi — JSON serialization library often paired with Mosby/MVP for model parsing in Retrofit-based data layers
• ReactiveX/RxAndroid — RxJava bindings for Android lifecycle; Mosby MVI heavily depends on RxAndroid 2.0.1 for observable scheduling
• google/architecture-components-samples — Google's modern MVP/MVVM alternative using LiveData/ViewModel; represents the architectural successor to Mosby in contemporary Android development
• sockeqwe/mosby-conductor — Official Mosby plugin for Conductor navigation library, extending MVP/MVI patterns to controller-based architectures
• google/dagger — Dependency injection framework commonly used with Mosby MVP presenters for testability and decoupling

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for MviBasePresenter lifecycle edge cases

The mvi-common module has MviBasePresenter.java and MviBasePresenterTest.java, but the integration tests in mvi-integration-test suggest there are lifecycle edge cases (MviFinishInOnCreateActivityTest, MviFinishInOnStartActivityTest) that aren't covered by unit tests. A new contributor could add detailed unit tests for presenter disposal, subscription management during rapid lifecycle transitions, and handling of RxJava 2 Observable completion scenarios.

• [ ] Review existing mvi-common/src/test/java/com/hannesdorfmann/mosby3/mvi/MviBasePresenterTest.java
• [ ] Add test cases for DisposableIntentObserver and DisposableViewStateObserver with edge cases (early disposal, re-subscription after completion)
• [ ] Add tests verifying proper cleanup of subscriptions when Activity/Fragment finishes in onCreate and onStart
• [ ] Add tests for concurrent intent emissions and state updates
• [ ] Reference the integration tests in mvi-integration-test/src/androidTest to ensure parity

Migrate Travis CI to GitHub Actions workflow with instrumented test support

The repo uses .travis.yml for CI but also has swarmer configuration (.buildscript/swarmer/) suggesting local emulator setup. There's no GitHub Actions workflow defined. A contributor could create a modern GitHub Actions workflow that runs both unit tests and instrumented Android tests via emulator, replacing the outdated Travis CI setup with better logging and parallelization.

• [ ] Create .github/workflows/android-test.yml with Android emulator setup (e.g., using reactivecircus/android-emulator-runner)
• [ ] Configure workflow to run ./gradlew test for unit tests in mvi-common
• [ ] Configure workflow to run ./gradlew connectedAndroidTest for integration tests in mvi-integration-test
• [ ] Add workflow_dispatch trigger and schedule for nightly builds
• [ ] Remove or deprecate .travis.yml with a note pointing to the new GitHub Actions workflow

Add RxJava 2 upgrade guide and backcompat tests for deprecated MVI patterns

The codebase shows mixed RxJava versions (rxjava2Version = '2.0.7' but also rxjavaVersion = '1.0.16' in gradle.properties). The mvi-common module uses RxJava 2 (DisposableIntentObserver, DisposableViewStateObserver) but there's no documented migration path from RxJava 1.x patterns. A contributor could add a migration guide document and create backward-compatibility tests validating that old RxJava 1.x-based presenters still work.

• [ ] Create docs/MIGRATION_RXJAVA1_TO_RXJAVA2.md documenting common patterns and breaking changes
• [ ] Add test module mvi-common/src/test for RxJava 1.x compatibility (testing with Observable.create vs Observable.defer patterns)
• [ ] Document how to adapt old CompositeSubscription-based presenters to RxJava 2 Disposables
• [ ] Add examples in README.md showing before/after RxJava 1 vs RxJava 2 presenter code
• [ ] Reference specific test files: DisposableIntentObserverTest.java and DisposableViewStateObserverTest.java

• Add unit test coverage for DisposableViewStateObserver.java (listed in file structure but no corresponding test file in mvi-common/src/test/). Create mvi-common/src/test/java/com/hannesdorfmann/mosby3/mvi/DisposableViewStateObserverTest.java following MviBasePresenterTest.java patterns.
• Document MVI pattern with a real code example in README.md. The current README links to blog posts but has no inline code sample; add a minimal presenter + intent + view example showing how to wire a login screen with username intent.
• Upgrade RxJava from 2.0.7 to 2.2.x and RxAndroid from 2.0.1 to 2.1.x in gradle.properties, then verify DisposableIntentObserver/DisposableViewStateObserver still handle subscription cancellation correctly. Create a test in mvi-common/src/test to confirm backward compatibility.

• High · Outdated Android Gradle Plugin — build.gradle - classpath 'com.android.tools.build:gradle:3.1.0'. The build.gradle uses Android Gradle Plugin version 3.1.0, which is from 2018 and contains known security vulnerabilities. This version lacks security patches and bug fixes from newer releases. Fix: Update to the latest stable Android Gradle Plugin version (currently 7.x or 8.x). Run 'gradle wrapper --gradle-version=<latest>' and update the plugin dependency.
• High · Outdated OkHttp Dependency — build.gradle - okhttpVersion = '2.3.0'. OkHttp version 2.3.0 is from 2014 and has multiple known security vulnerabilities including issues with certificate pinning and TLS configuration. This version is severely outdated. Fix: Update to OkHttp 4.9.x or later. Version 2.3.0 reached end-of-life years ago and should not be used in production applications.
• High · Outdated Retrofit Dependency — build.gradle - retrofitVersion = '1.9.0'. Retrofit version 1.9.0 is from 2015 and lacks modern security features and bug fixes. It has known vulnerabilities and is no longer maintained. Fix: Upgrade to Retrofit 2.9.x or later. The 1.x branch is deprecated and no longer receives security updates.
• High · Outdated Support Library Versions — build.gradle - supportLibVersion = '28.0.0'. Support library version 28.0.0 is from 2018 and no longer receives security updates. Google recommends using AndroidX instead. Multiple security patches have been released since then. Fix: Migrate from Support Library to AndroidX (androidx.appcompat:appcompat:1.6.x or later) which receives regular security updates.
• Medium · Outdated RxJava Dependencies — build.gradle - rxjava2Version = '2.0.7', rxAndroid2Version = '2.0.1'. RxJava2 version 2.0.7 and RxAndroid2 version 2.0.1 are outdated (from 2016). While not directly a security issue, they may have compatibility issues and lack bug fixes. Fix: Update to RxJava 2.2.x or consider migrating to RxJava 3.x. Update RxAndroid to 2.1.x or later.
• Medium · Outdated Build Tools Version — build.gradle - buildToolsVersion = '28.0.1', targetSdk = 25, compileSdkVersion = 28. Build Tools version 28.0.1 is from 2018 and may lack security improvements and bug fixes available in newer versions. Target SDK 25 is also outdated. Fix: Update buildToolsVersion to 33.x or later and set targetSdk to 34 (or current latest) to comply with Google Play Store requirements and receive security patches.
• Medium · Encrypted Secret Key File Present — .buildscript/key.gpg.enc. File '.buildscript/key.gpg.enc' appears to be an encrypted GPG key. While encrypted, the presence of deployment keys in the repository (even encrypted) poses a risk if decryption keys are compromised. Fix: Store deployment keys in a secure secrets management system (e.g., Travis CI secrets, GitHub Secrets). Remove encrypted keys from the repository. Use environment-based key injection for CI/CD pipelines.
• Medium · Outdated Mockito Test Dependency — build.gradle - mockitoVersion = '2.0.5-beta'. Mockito version 2.0.5-beta is outdated and from 2016. Beta versions should not be used in production code, and this version lacks security and bug fixes. Fix: Update to Mockito 4.x or 5.x (latest stable). Remove beta/RC versions from test dependencies.
• Low · — undefined. undefined Fix: undefined

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.