refactor: Modularize project and introduce convention plugins

This commit refactors the project into a multi-module architecture, separating concerns into `core` and `feature` modules. This modularization improves scalability, maintainability, and build times by clearly defining dependencies and responsibilities. Gradle convention plugins have been introduced to standardize module configurations and streamline the build process.

### Core Changes:
- **feat(project)!**: Migrated from a monolithic `composeApp` to a multi-module architecture. Source code has been moved into new `core` and `feature` modules (e.g., `core/data`, `feature/settings/presentation`).
- **feat(build)**: Introduced Gradle convention plugins (`kmp.library`, `kmp.feature`, `kmp.ui`, `kmp.ui.feature`) to standardize module configurations for Kotlin Multiplatform.
- **feat(di)**: Centralized and modularized Koin dependency injection. Each feature now has its own DI module, improving separation of concerns.
- **refactor(core)**: Moved shared components, models, and utilities from `composeApp` into the `core` module, splitting them into `core:data`, `core:domain`, and `core:presentation` layers.
- **refactor(navigation)**: Migrated from a custom navigation implementation to `androidx.navigation:navigation-compose` for more robust and standardized navigation handling.
- **feat(i18n)**: Organized string resources into per-feature directories for better localization management, adding translations for Chinese, Turkish, and Russian.

### Detailed Changes:
- **refactor(data)!**: Relocated all data-layer components (DAOs, DTOs, repositories, services) from `composeApp` to their respective `core` or `feature` data modules.
- **refactor(domain)!**: Moved domain models and use cases to the `core:domain` and feature-specific domain modules.
- **refactor(ui)!**: Migrated presentation-layer components (Composables, ViewModels, UI state) to `core:presentation` or feature-specific presentation modules. This includes themes, components like `RepositoryCard`, and utilities.
- **refactor(services)**: Relocated platform-specific implementations like `Downloader`, `Installer`, and `BrowserHelper` to the `core:data` module.
- **feat(build)**: Enabled `-Xexpect-actual-classes` and `-Xmulti-dollar-interpolation` compiler arguments.
- **deps**: Upgraded `navigation-compose` to `2.9.1`.

Author: rainxchzed

build-logic/convention/src/main/kotlin/zed/rainxch/githubstore/convention/KotlinMultiplatform.kt

@@ -16,6 +16,7 @@ internal fun Project.configureKotlinMultiplatform() {
     extensions.configure<KotlinMultiplatformExtension> {
         compilerOptions {
             freeCompilerArgs.add("-Xexpect-actual-classes")
+            freeCompilerArgs.add("-Xmulti-dollar-interpolation")
             freeCompilerArgs.add("-opt-in=kotlin.RequiresOptIn")
             freeCompilerArgs.add("-opt-in=kotlin.time.ExperimentalTime")
         }

build-logic/convention/src/main/kotlin/zed/rainxch/githubstore/convention/PathUtil.kt

@@ -9,7 +9,7 @@ fun Project.pathToPackageName(): String {
         .replace("-", "_")
         .lowercase()
 
-    return "zed.rainxch${relativePackageName  }"
+    return "zed.rainxch${relativePackageName}"
 }
 
 fun Project.pathToResourcePrefix(): String {

composeApp/build.gradle.kts

@@ -56,13 +56,14 @@ kotlin {
             implementation(projects.feature.starred.data)
             implementation(projects.feature.starred.presentation)
 
-
             implementation(libs.jetbrains.compose.navigation)
             implementation(libs.bundles.koin.common)
+            implementation(libs.liquid)
+            implementation(libs.jetbrains.compose.material.icons.extended)
 
             implementation(compose.runtime)
             implementation(compose.foundation)
-            implementation(compose.material3)
+            implementation(libs.jetbrains.compose.material3)
             implementation(compose.ui)
             implementation(compose.components.resources)
             implementation(compose.components.uiToolingPreview)

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/MainActivity.kt

@@ -10,22 +10,14 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 
 class MainActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
-        var shouldShowSplashScreen = true
-
-        installSplashScreen().setKeepOnScreenCondition {
-            shouldShowSplashScreen
-        }
+        installSplashScreen()
 
         enableEdgeToEdge()
 
         super.onCreate(savedInstanceState)
 
         setContent {
-            App(
-                onAuthenticationChecked = {
-                    shouldShowSplashScreen = false
-                }
-            )
+            App()
         }
     }
 }

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/app/di/PlatformModules.android.kt

@@ -1,41 +1,27 @@
 package zed.rainxch.githubstore
 
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material3.CircularWavyProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.saveable.rememberSerializable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.savedstate.compose.serialization.serializers.SnapshotStateListSerializer
+import androidx.navigation.compose.rememberNavController
 import org.jetbrains.compose.ui.tooling.preview.Preview
 import org.koin.compose.viewmodel.koinViewModel
-import zed.rainxch.githubstore.app.state.components.RateLimitDialog
+import zed.rainxch.core.presentation.theme.GithubStoreTheme
+import zed.rainxch.core.presentation.utils.ApplyAndroidSystemBars
 import zed.rainxch.githubstore.app.navigation.AppNavigation
 import zed.rainxch.githubstore.app.navigation.GithubStoreGraph
-import zed.rainxch.githubstore.core.presentation.theme.GithubStoreTheme
-import zed.rainxch.githubstore.core.presentation.utils.ApplyAndroidSystemBars
+import zed.rainxch.githubstore.app.state.components.RateLimitDialog
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 @Preview
-fun App(
-    onAuthenticationChecked: () -> Unit = { },
-) {
+fun App() {
     val viewModel: MainViewModel = koinViewModel()
     val state by viewModel.state.collectAsStateWithLifecycle()
 
-    val navBackStack = rememberSerializable(
-        serializer = SnapshotStateListSerializer<GithubStoreGraph>()
-    ) {
-        mutableStateListOf(GithubStoreGraph.HomeScreen)
-    }˜
+    val navBackStack = rememberNavController()
 
     GithubStoreTheme(
         fontTheme = state.currentFontTheme,
@@ -45,24 +31,6 @@ fun App(
     ) {
         ApplyAndroidSystemBars(state.isDarkTheme)
 
-        LaunchedEffect(state.isCheckingAuth) {
-            if (!state.isCheckingAuth) {
-                onAuthenticationChecked()
-            }
-        }
-
-        if (state.isCheckingAuth) {
-            Box(
-                modifier = Modifier.fillMaxSize(),
-                contentAlignment = Alignment.Center
-            ) {
-                CircularWavyProgressIndicator()
-            }
-
-            return@GithubStoreTheme
-        }
-
-
         if (state.showRateLimitDialog && state.rateLimitInfo != null) {
             RateLimitDialog(
                 rateLimitInfo = state.rateLimitInfo,
@@ -73,14 +41,13 @@ fun App(
                 onSignIn = {
                     viewModel.onAction(MainAction.DismissRateLimitDialog)
 
-                    navBackStack.clear()
-                    navBackStack.add(GithubStoreGraph.AuthenticationScreen)
+                    navBackStack.navigate(GithubStoreGraph.AuthenticationScreen)
                 }
             )
         }
 
         AppNavigation(
-            navBackStack = navBackStack
+            navController = navBackStack
         )
     }
 }

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/core/domain/AndroidPlatform.kt

@@ -1,8 +1,8 @@
 package zed.rainxch.githubstore
 
+import zed.rainxch.core.domain.model.AppTheme
+import zed.rainxch.core.domain.model.FontTheme
 import zed.rainxch.core.domain.model.RateLimitInfo
-import zed.rainxch.githubstore.core.presentation.model.AppTheme
-import zed.rainxch.githubstore.core.presentation.model.FontTheme
 
 data class MainState(
     val isLoggedIn: Boolean = false,

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/feature/details/presentation/utils/isLiquidTopbarEnabled.android.kt

@@ -5,29 +5,20 @@ import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.drop
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import zed.rainxch.core.data.data_source.TokenDataSource
-import zed.rainxch.core.domain.logging.GitHubStoreLogger
-import zed.rainxch.core.domain.model.Platform
 import zed.rainxch.core.domain.repository.AuthenticationState
 import zed.rainxch.core.domain.repository.InstalledAppsRepository
 import zed.rainxch.core.domain.repository.RateLimitRepository
 import zed.rainxch.core.domain.repository.ThemesRepository
-import zed.rainxch.core.domain.system.PackageMonitor
+import zed.rainxch.core.domain.use_cases.SyncInstalledAppsUseCase
 
 class MainViewModel(
     private val themesRepository: ThemesRepository,
-    private val appStateManager: AppStateManager,
-    private val packageMonitor: PackageMonitor,
     private val installedAppsRepository: InstalledAppsRepository,
     private val authenticationState: AuthenticationState,
     private val rateLimitRepository: RateLimitRepository,
-    private val platform: Platform,
-    private val logger: GitHubStoreLogger
+    private val syncUseCase: SyncInstalledAppsUseCase
 ) : ViewModel() {
 
     private val _state = MutableStateFlow(MainState())
@@ -39,6 +30,10 @@ class MainViewModel(
                 .isUserLoggedIn()
                 .collect { isLoggedIn ->
                     _state.update { it.copy(isLoggedIn = isLoggedIn) }
+
+                    if (isLoggedIn) {
+                        rateLimitRepository.clear()
+                    }
                 }
         }
 
@@ -92,60 +87,16 @@ class MainViewModel(
         }
 
         viewModelScope.launch(Dispatchers.IO) {
-            try {
-                val installedPackageNames = packageMonitor.getAllInstalledPackageNames()
-
-                val appsInDb = installedAppsRepository.getAllInstalledApps().first()
-
-                appsInDb.forEach { app ->
-                    if (!installedPackageNames.contains(app.packageName)) {
-                        logger.d { "App ${app.packageName} no longer installed (not in system packages), removing from DB" }
-                        installedAppsRepository.deleteInstalledApp(app.packageName)
-                    } else if (app.installedVersionName == null) {  // Migrate only if new fields unset
-                        if (platform.type == Platform.ANDROID) {
-                            val systemInfo = packageMonitor.getInstalledPackageInfo(app.packageName)
-                            if (systemInfo != null) {
-                                installedAppsRepository.updateApp(app.copy(
-                                    installedVersionName = systemInfo.versionName,
-                                    installedVersionCode = systemInfo.versionCode,
-                                    latestVersionName = systemInfo.versionName,
-                                    latestVersionCode = systemInfo.versionCode
-                                ))
-                                logger.d { "Migrated ${app.packageName}: set versionName/code from system" }
-                            } else {
-                                installedAppsRepository.updateApp(app.copy(
-                                    installedVersionName = app.installedVersion,
-                                    installedVersionCode = 0L,
-                                    latestVersionName = app.installedVersion,
-                                    latestVersionCode = 0L
-                                ))
-                                logger.d { "Migrated ${app.packageName}: fallback to tag as versionName" }
-                            }
-                        } else {
-                            installedAppsRepository.updateApp(app.copy(
-                                installedVersionName = app.installedVersion,
-                                installedVersionCode = 0L,
-                                latestVersionName = app.installedVersion,
-                                latestVersionCode = 0L
-                            ))
-                            logger.d { "Migrated ${app.packageName} (desktop): fallback to tag as versionName" }
-                        }
-                    }
-                }
-
-                logger.d { "Robust system existence sync and data migration completed" }
-            } catch (e: Exception) {
-                logger.e { "Failed to sync existence or migrate data: ${e.message}" }
+            syncUseCase().onSuccess {
+                installedAppsRepository.checkAllForUpdates()
             }
-
-            installedAppsRepository.checkAllForUpdates()
         }
     }
 
     fun onAction(action: MainAction) {
         when (action) {
             MainAction.DismissRateLimitDialog -> {
-                appStateManager.dismissRateLimitDialog()
+                _state.update { it.copy(showRateLimitDialog = false) }
             }
         }
     }