claude-android-ninja

### Implementation of Modular Feature Module for 'User Profile' in 'MyApp'

**1. Project Structure Updates:**
- Created new module `feature-user-profile` under `modules/` with the following structure:
  - `src/main/java/com/myapp/feature/userprofile/` (Kotlin sources)
  - `src/main/res/` (Compose resources)
  - `src/test/java/com/myapp/feature/userprofile/` (Unit tests)
  - `src/androidTest/java/com/myapp/feature/userprofile/` (UI tests)

**2. Gradle Configuration:**
- Added `feature-user-profile/build.gradle.kts`:
```kotlin
plugins {
    id("com.android.library")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.myapp.feature.userprofile"
    compileSdk = 34
    
defaultConfig {
        minSdk = 24
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        }
    }
    buildFeatures {
        compose = true
    }
    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.3"
    }
}

dependencies {
    implementation(project(":core:ui"))
    implementation(project(":core:domain"))
    implementation("androidx.navigation:navigation-compose:2.7.4")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1")
    testImplementation("junit:junit:4.13.2")
    testImplementation("org.mockito:mockito-core:5.3.1")
    androidTestImplementation("androidx.compose.ui:ui-test-junit4:1.5.0")
}
```

- Updated `build.gradle.kts` in root project to bump dependency versions:
```kotlin
val navigationVersion by extra("2.7.4")
val composeVersion by extra("1.5.3")
```

**3. Navigation Integration:**
- Added route `user-profile/{userId}` to `app/src/main/java/com/myapp/navigation/AppNavGraph.kt`:
```kotlin
composable("user-profile/{userId}") { backStackEntry ->
    val userId = backStackEntry.arguments?.getString("userId")
    UserProfileScreen(userId = userId, onBackClick = { navController.popBackStack() })
}
```

**4. Feature Implementation:**
- Created `UserProfileViewModel.kt` in `feature-user-profile`:
```kotlin
class UserProfileViewModel(
    private val getUserProfileUseCase: GetUserProfileUseCase,
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    private val userId: String = savedStateHandle.get<String>("userId") ?: ""
    val uiState = mutableStateOf<UserProfileUiState>(UserProfileUiState.Loading)
    
    init {
        viewModelScope.launch {
            uiState.value = try {
                UserProfileUiState.Success(getUserProfileUseCase(userId))
            } catch (e: Exception) {
                UserProfileUiState.Error(e.message ?: "Unknown error")
            }
        }
    }
}
```

- Implemented `UserProfileScreen.kt` with Compose:
```kotlin
@Composable
fun UserProfileScreen(
    userId: String,
    onBackClick: () -> Unit,
    viewModel: UserProfileViewModel = viewModel()
) {
    val uiState by viewModel.uiState.collectAsState()
    
    when (val state = uiState) {
        is UserProfileUiState.Loading -> LoadingIndicator()
        is UserProfileUiState.Success -> UserProfileContent(user = state.user, onBackClick)
        is UserProfileUiState.Error -> ErrorMessage(state.message)
    }
}
```

**5. Testing:**
- Unit test for `UserProfileViewModel`:
```kotlin
@Test
fun `ViewModel emits Success state when use case succeeds`() {
    val useCase = mockk<GetUserProfileUseCase>()
    val user = User("1", "John Doe", "[email protected]")
    every { useCase(any()) } returns user
    
    val viewModel = UserProfileViewModel(useCase, SavedStateHandle(mapOf("userId" to "1")))
    
    assert(viewModel.uiState.value is UserProfileUiState.Success)
}
```

- UI test for `UserProfileScreen`:
```kotlin
@HiltAndroidTest
class UserProfileScreenTest {
    @get:Rule
    val composeTestRule = createComposeRule()
    
    @Test
    fun screen_displays_user_data() {
        composeTestRule.setContent {
            MyAppTheme {
                UserProfileScreen("1", {})
            }
        }
        
        composeTestRule.onNodeWithText("John Doe").assertExists()
        composeTestRule.onNodeWithText("[email protected]").assertExists()
    }
}
```

**6. Documentation:**
- Updated `README.md` under 'Module Additions':
```markdown
### User Profile Module
- **Purpose**: Display and manage user profile data
- **Dependencies**: Core UI, Core Domain, Navigation3
- **Testing**: Unit tests cover ViewModel logic; UI tests verify Compose rendering
- **Navigation**: Accessible via `user-profile/{userId}` route
```

**7. Next Steps:**
- Merge PR and run `./gradlew assembleDebug` to verify build
- Add feature to CI pipeline for automated testing
- Review with team for feedback on implementation