kurikomi-labs/komi-store

Komi Store is a cross-platform application for Android and Desktop that manages and installs APKs from GitHub and Forgejo repositories. It provides features for discovering apps, tracking updates, and performing silent installations via elevated privilege backends like Shizuku and Root. The system includes a comprehensive library management interface with search, filtering, and deep-linking capabilities across both platforms.

The JVM module now includes a dedicated HTTP client factory and digest verifier. The client factory configures OkHttp to trust the OS-installed root certificates (enabling compatibility with corporate MITM proxies like Watt Toolkit) and supports dynamic proxy configurations, including system proxies, HTTP proxies with authentication, and SOCKS proxies. Additionally, a streaming SHA-256 digest verifier is added for file integrity checks on Desktop/JVM platforms.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/network · high confidence

Users can now view repository issues, pull requests, and security advisories directly within the app. This change introduces dedicated screens for listing and filtering issues and pull requests by state (open/closed), viewing detailed issue threads with comments and reactions, and browsing security advisories with severity badges and security policy markdown. The implementation includes the data layer (repository, DTOs, mappers), domain models, and presentation components (UI screens, top bars, loading/error states, and markdown rendering) for these three areas.

feature/repo-pages · high confidence

The import feature now includes new utility components to support platform-specific behaviors: a PackageVisibilityRequester interface for managing permission requests, a ReducedMotion composition local to respect user accessibility preferences, and expect functions to retrieve the system SDK level and reduced motion settings.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/import/util · high confidence

The Android external app scanner now provides richer context for detected applications by classifying their installer source (e.g., Google Play, F-Droid, OEM stores, browsers, or sideload) and computing SHA-256 signing fingerprints. System apps and packages with OEM prefixes are filtered out of the snapshot to reduce noise. This allows the app to better distinguish between official store installations, third-party sources, and pre-installed system software, improving the accuracy of external app detection and security analysis.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/external · high confidence

The Android data layer now includes a comprehensive background update system using WorkManager (AutoUpdateWorker) and a BootReceiver to automatically check for and install updates. This change introduces silent installation support via Shizuku, Dhizuku, and Root backends, alongside a new aggressive OEM detector to handle battery optimization settings on devices like Xiaomi and OnePlus. Users also benefit from improved download reliability with a custom OkHttp-based downloader, atomic file operations to prevent data clobbering, and system-shade progress notifications for both downloads and pending installations.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services · high confidence

The Android-specific network module now includes an AndroidDigestVerifier that performs streaming SHA-256 file integrity checks, improving download security by verifying file digests without loading entire files into memory. Additionally, the platform HTTP client factory has been updated to support dynamic proxy configurations, including system proxy resolution via Android system properties, manual HTTP and SOCKS proxy settings, and authentication for both proxy types.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/network · high confidence

A new Koin module for the Android platform has been added to wire up Android-specific implementations for core domain interfaces. This includes bindings for the downloader, installer (with support for Shizuku, Dhizuku, and root backends), APK inspector, external app scanner, and various system services like package monitoring and download progress notifications. Additionally, it configures DataStore instances for general preferences and announcements, and integrates KSafe for secure storage of tokens, preferences, and cache data.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/di · high confidence

Users on desktop platforms can now launch installed applications directly from the app, open external URLs in their default web browser, and manage clipboard content. Additionally, the app supports exporting and importing configuration or data via JSON files using native file pickers, and allows sharing text to the system clipboard.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/utils · high confidence

The application now supports desktop environments (Windows, macOS, Linux) by introducing a suite of platform-specific service implementations. This includes a new OkHttp-based downloader that handles unique download IDs, atomic file moves, and proxy configurations, alongside a file locations provider that manages app-specific and user-scoped download directories. A comprehensive installer service has been added to handle various package formats (DEB, RPM, Arch, AppImage, MSI, EXE, DMG) and detect system architecture, while stub implementations for package monitoring, progress notifications, and update scheduling ensure the core data layer functions correctly on desktop platforms.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services · high confidence

The desktop application now includes a crash guard that disables the Compose accessibility bridge on macOS and suppresses related crashes, alongside a new crash reporter that logs session and crash data to platform-specific directories. Deep linking is implemented across Windows, Linux, and macOS via the 'githubstore://' protocol, allowing the app to forward links to a running instance. Additionally, the app now remembers and restores the desktop window's size and position across launches, and the main entry point has been renamed to DesktopApp.kt.

composeApp/src/jvmMain/kotlin · high confidence

Users can now install Komi Store via Homebrew on macOS using \brew install --cask komi-store\. The distribution includes a cask file supporting both Apple Silicon and Intel architectures, with automatic updates to the version and checksums handled by a GitHub workflow upon release. Note that the application is currently unsigned, so users must manually remove the quarantine attribute using \xattr -dr com.apple.quarantine\ after installation to bypass macOS Gatekeeper.

dist · high confidence

This change introduces the foundational data module for the developer profile feature, establishing the infrastructure to fetch and map GitHub user and repository information. It includes Koin dependency injection bindings for the developer profile repository, mappers to convert network DTOs (GitHubUserResponse, GitHubRepoResponse) and network models into domain entities (DeveloperProfile, DeveloperRepository), and the necessary Android manifest and build ignore files to support the new module structure.

feature/dev-profile/data · high confidence

The repository has been initialized with the core project structure, including the main application entry point, build configuration, and a comprehensive set of documentation files. This includes a detailed developer guide (CLAUDE.md) outlining the Clean Architecture, MVI state management, and Koin dependency injection patterns, alongside standard community guidelines such as CONTRIBUTING.md, CODE\_OF\_CONDUCT.md, and SECURITY.md. The README has been expanded to feature the 'Komi Store' branding, download links for Android and Desktop platforms, and community support channels.

(repo-wide) · high confidence

The AppsRoot composable now serves as the central entry point for the Apps feature, wiring together the main list view with several overlay components including LinkAppBottomSheet, AdvancedAppSettingsBottomSheet, VariantPickerDialog, ImportSummarySheet, and PendingUninstallSheet. A key behavioral change is the addition of a lifecycle observer that triggers a re-check for updates when the screen resumes, ensuring users see the latest app states after returning from other screens. The screen also handles navigation events for repo details and external imports, and manages toast notifications for success and error states.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation · high confidence

A new Developer Profile screen has been added, allowing users to view a developer's profile information, contribution calendar, and a list of their repositories. The repository list supports filtering by status (With Releases, With Installable, Installed, Favorites) and sorting by update date, stars, or name. Users can navigate to individual repository details, open external links, and jump to other user profiles via clickable mentions in the bio. The interface includes a search bar, filter pills, and a sort dropdown, with optional scrollbar support and arrow key navigation for desktop platforms.

feature/dev-profile/presentation · high confidence

The Dhizuku backend for silent app installation is now implemented, allowing the app to install packages without user interaction on supported devices. This service uses unguessable tokens for install and uninstall result intents to ensure secure communication, and verifies the installed package state against the expected package name and version code if the operation times out, preventing false failure reports. It also correctly handles and surfaces the PENDING\_USER\_ACTION status required by Android 14+ for update ownership, and abandons staged install sessions on failure to clean up resources.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku · high confidence

Users can now view their starred repositories in a new Favourites screen, which includes a search bar to filter by name, owner, description, or language, and a sort menu to order items by recently added or name. The list displays a verified badge on repositories owned by the current user and supports keyboard arrow navigation. A new Import Stars flow allows users to add repositories to their favourites by entering a GitHub username.

feature/favourites/presentation · high confidence

This change adds a new Feed feature, including the domain repository interface, a data implementation with caching and offline fallback logic, and a presentation layer featuring a platform picker, category strip, and scrollable content view. It also introduces utility components for handling desktop toolbar deep links and keyboard navigation events, alongside an App Info screen for the Tweaks feature.

(repo-wide) · high confidence

A new Starred Picker screen has been added, allowing users to browse their starred GitHub repositories and filter for those that ship Android APKs. The interface displays repository details including star counts, latest release tags, and descriptive badges indicating whether a repository ships an APK or is already tracked. Users can sort the list by recent stars, alphabetical order, or total star count, and the view includes lifecycle-aware state management for loading, scanning, and empty states.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/starred · high confidence

The Starred Repositories screen now allows users to filter their starred list using a search bar and sort the results by recently starred, name, or star count. The repository list displays a verified badge on items owned by the current user, and the interface supports optional scrollbars and arrow-key navigation for accessibility.

feature/starred/presentation · high confidence

The data layer now includes a new BackendApiClient that routes search, feed, and category requests through a central backend (api.github-store.org) instead of directly to GitHub, supporting dynamic proxy configuration and GitHub token forwarding for authenticated requests. A new ProxyManager and ProxyTesterImpl provide system proxy resolution and connectivity testing, while a MirrorRewriteInterceptor enables traffic mirroring to alternative hosts. The network stack also adds a ForgejoApiClient for Codeberg/Forgejo support, a fallback policy for backend errors, and specialized exception handling for rate limits and refresh budgets.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/network · high confidence

The home data module now includes a new CachedRepositoriesDataSource interface and its implementation, enabling the retrieval of cached trending, hot release, popular, and topic repositories. This change introduces mappers to convert backend repository responses into cached summaries and subsequently into domain models, ensuring that repository details such as platform availability, download counts, and release dates are correctly propagated through the data layer.

feature/home/data · high confidence

The repository has been modularized to include a new \feature/details/presentation\ module, which consolidates the UI layer for application and repository details. This update introduces an APK Inspection bottom sheet that allows users to view detailed package information, including permissions, components, and signing identity. Additionally, the module adds an About screen with support for translating README content into different languages via a dedicated language picker, and implements an APK Inspect button with an animated coachmark to guide users to the new inspection capability.

feature/details/presentation · high confidence

The presentation layer for the Profile feature has been restructured into a new \feature/profile/presentation\ module, replacing the previous Settings-based layout. Users now access a dedicated Profile screen that organizes navigation into distinct sections: Library (Starred and Favourite repositories, Recently Viewed), Updates (What's New history and Announcements), App (Tweaks and About), and Account (Logout). The Announcements section includes a new screen with expandable cards, severity-based visual indicators, and a bottom sheet for muting specific categories. The What's New section provides a history view of release notes. Additionally, a confirmation dialog has been added for the logout action, and the profile list supports arrow-key navigation for accessibility.

feature/profile/presentation · high confidence

This change establishes the domain layer for the repository details feature, introducing key interfaces and models to support release filtering, repository data fetching, and installation verification. It defines the \ReleaseCategory\ enum to categorize releases (Stable, Pre-release, All) and adds the \DetailsRepository\ interface to handle fetching repository summaries, stats, user profiles, and README content. The \InstallationManager\ and \AttestationVerifier\ interfaces are introduced to manage APK validation, signing fingerprint checks, and GitHub artifact attestation verification. Additionally, \VersionHelper\ is added to provide semantic version comparison and downgrade detection logic, while \TranslationRepository\ supports translating 'About' and 'What's New' sections.

feature/details/domain · high confidence

The home feature now defines its core domain layer, introducing \HomeCategory\ (Trending, Hot Release, Most Popular) and \TopicCategory\ enums to categorize repositories. A new \HomeRepository\ interface exposes methods for fetching these categories and searching by topic, supporting multi-platform filtering via \DiscoveryPlatform\ and returning paginated results. This establishes the data contract for the home screen's content discovery logic.

feature/home/domain · high confidence

The search data module has been restructured into a new modular component that implements a backend-first search strategy, attempting to fetch results from the backend API before falling back to GitHub or Forgejo sources. This change introduces a new \SearchRepositoryImpl\ that integrates with a \BackendApiClient\ and a \CacheManager\ to store and retrieve search results, improving performance by reducing redundant network calls. The module also includes a \SearchHistoryRepositoryImpl\ for managing local search history and a DI module (\SharedModule\) to wire up these dependencies using Koin.

feature/search/data · high confidence

Users can now access a dedicated screen displaying a history of repositories they have recently visited. This feature presents a scrollable, adaptive staggered grid of repository cards, each showing the owner, name, description, primary language, and the time since it was last viewed. The interface supports keyboard navigation via arrow keys, allows users to navigate to a repository's details or the developer's profile directly from the list, and includes the ability to remove specific items from the viewing history.

feature/recently-viewed/presentation · high confidence

This change adds the Android platform layer for core utility helpers, enabling the app to launch installed applications, open URLs in a browser, interact with the system clipboard, and share or pick files. Specifically, it implements the \AppLauncher\ to start apps via their package names, the \BrowserHelper\ to open web links with failure callbacks, the \ClipboardHelper\ for copying and retrieving text, and the \ShareManager\ to handle text/file sharing via system intents and file picking using the Android Activity Result API.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/utils · high confidence

The data layer now provides a concrete implementation of the AppsRepository interface, wired into the application via a new Koin module (SharedModule.kt). This implementation handles core app management tasks including retrieving installed applications, launching apps, fetching repository information, and determining the latest releases. It integrates with backend APIs and GitHub clients to resolve release data, supporting fallback mechanisms and pre-release filtering based on user tweaks.

feature/apps/data/src/commonMain/kotlin/zed/rainxch/apps/data · high confidence

The application now registers a dedicated Koin module for the Desktop platform, wiring domain interfaces to their desktop implementations. This includes binding the Downloader, Installer, and DigestVerifier to their desktop counterparts, configuring KSafe instances for secure storage of tokens, preferences, and announcements cache, and setting up the AppDatabase and DataStore instances. This change ensures that desktop users receive the correct platform-specific behaviors for downloads, installation, and data persistence.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/di · high confidence

The app now supports navigation via deep links for key sections including the home screen, apps list, repository details, search, favorites, and recently viewed items. It also handles authentication handoffs and errors, as well as specific utility pages like tweaks, feedback, and about. The system parses both custom URI schemes (githubstore://) and standard GitHub URLs, applying strict validation to prevent injection attacks and ensuring that only valid repository paths are processed.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/deeplink · high confidence

The \core/domain\ module now provides the foundational domain models and repository interfaces that drive the application's behavior. This includes platform detection helpers (Android/Desktop) and appearance settings (themes, fonts, accent colors) that define the user interface's look and feel. It also introduces the \InstalledAppsRepository\ and \TweaksRepository\ interfaces, which manage the state of installed applications, update preferences, and user customization settings, forming the backend logic for the app's library and settings screens.

core/domain · high confidence

The feedback submission flow now includes structured model types to categorize and route user input. FeedbackCategory defines four distinct categories (Bug, Feature Request, Change Request, Other) that map to specific GitHub labels. FeedbackTopic provides eight granular topics (such as Install/Update, Search, UI/UX, and Performance) to further classify the nature of the feedback. FeedbackChannel specifies the two available submission methods: Email and GitHub. These models provide the necessary data structure for the presentation layer to handle feedback selection and submission.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/model · high confidence

This change adds several new model classes to the presentation layer to support upcoming UI features. It introduces AppSortRule to enable sorting apps by updates or name, LinkStep to define the stages of the app linking flow, and ImportSummaryBucket to categorize import results. Additionally, it adds AdvancedPreviewMessage and VariantPickerError to handle specific preview and variant selection states.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/model · high confidence

The application now uses a new CacheManager that combines an in-memory HashMap with a Room database for persistent storage. This change ensures faster data access via the memory cache while maintaining durability through the database. A background coroutine periodically cleans up expired entries from both layers to prevent memory bloat and stale data. The system also includes specific TTLs for different data types, such as 24 hours for home repositories and 3 hours for feeds, and handles concurrent access safely using mutexes.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/cache · high confidence

The presentation layer now uses a new set of custom Compose components (KomiBadge, KomiButton, KomiChip, KomiTextField, etc.) that adapt their appearance based on the selected 'personality' (Classic or Manga). This includes a new badge system for notifications and counts, themed buttons and chips with specific visual styles, and a personality-aware markdown image transformer that handles GitHub-style badges and images. Additionally, a new \AdaptiveDetailArgs\ class is introduced to pass repository details to the details screen.

presentation · high confidence

A new RootStatus enum has been added to define the states of root access availability (NOT\_AVAILABLE, PERMISSION\_NEEDED, READY), providing the foundational data structure for root permission detection within the application.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/root · high confidence

The presentation layer now features a new 'Komi' design system that allows the application's visual style to switch between 'Classic' and 'Manga' personalities. This change introduces a suite of new UI components—including bottom and top bars, buttons, floating action buttons, and an adaptive list-detail layout—that dynamically render based on the active personality. Users will see distinct visual treatments for navigation, actions, and content layouts, with the Manga personality featuring unique styling such as hard shadows, ink focus rings, and specific color palettes, while the Classic personality maintains a more standard Material 3 appearance.

core/presentation/src/commonMain/kotlin · high confidence

This change introduces JVM-targeted implementations for several presentation utilities within the \feature/apps/presentation\ module. Specifically, it adds \InstalledAppIcon.jvm.kt\ to render a default app icon, \PackageVisibilityRequester.jvm.kt\ to always grant package visibility permissions, \ReducedMotionProvider.jvm.kt\ to disable reduced motion preferences, and \SdkLevelProvider.jvm.kt\ to return null for SDK level detection. These components provide the necessary platform-specific behavior for the JVM environment, ensuring the presentation layer functions correctly without relying on Android-specific APIs.

feature/apps/presentation/src/jvmMain/kotlin/zed/rainxch/apps/presentation · high confidence

Komi Store is now available as a Flatpak (com.kurikomi.komistore) for Linux users. The package bundles the application with a JetBrains Runtime JRE and uses an offline Maven repository to resolve dependencies, ensuring reproducible builds. Because the Flatpak sandbox restricts system access, the app is browse-and-download only: release assets are saved to the user's Downloads folder for manual installation, rather than installing system packages automatically. The build forces the X11 backend via XWayland, as the underlying Compose/Skiko rendering stack does not yet support native Wayland.

packaging/flatpak · high confidence

A new Licenses screen has been added to the Tweaks section, allowing users to view a list of third-party libraries and their associated licenses. The screen displays an introductory title and body text, handles loading and error states with a progress indicator and error message, and presents each library in a scrollable list where tapping a row opens the library's URL in an external browser.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/licenses · high confidence

The Tweaks settings area now includes dedicated screens for managing hidden repositories and host tokens. Users can view, unhide, and bulk-unhide repositories via the Hidden Repositories screen, and manage per-host authentication tokens (including adding, editing, deleting with undo, and validating tokens) via the Host Tokens screen. These screens are integrated into the main Tweaks navigation, with the Host Tokens entry linking to the new management UI and the Hidden Repositories screen accessible from the Tweaks root.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation · high confidence

This change introduces the presentation layer for the new 'Tweaks' settings feature, adding a suite of new UI components in the \feature/tweaks/presentation\ module. Users will see a dedicated settings screen with a desktop-optimized layout (sidebar navigation) and mobile-optimized sheets, allowing them to manage appearance (Manga vs. Classic personality, accent colors, dark mode, AMOLED black), connectivity (custom forges, mirrors), privacy (hidden repositories, host tokens), and app preferences (language, feedback). The UI includes specific components like a clear-downloads confirmation dialog, a language picker with search, and stub screens for upcoming features.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components · high confidence

The apps screen now features a redesigned interface with several new capabilities. A new Advanced App Settings bottom sheet allows users to filter GitHub assets, toggle fallback to older releases, and manage preferred APK variants. The main list view now supports sectioned, compact rows for installed apps, each with an overflow menu to skip updates or toggle pre-release checks. Users can also sort the app list by updates, recency, or name, and manage their library via a new top bar that includes options to import apps (including Obtainium format), export the library, and add apps from starred repositories. An Import Summary sheet provides detailed feedback on import results, categorizing apps into imported, skipped, non-GitHub, and failed buckets.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/components · high confidence

This change introduces four new service implementations in the core data layer: BuildKonfigAppVersionInfo exposes the app's version code and name; DefaultSystemInstallSerializer manages concurrent system install requests with a single-flight gate and configurable timeout; FileLocationsProvider defines interfaces for managing app and user download directories, cache sizes, and executable permissions; and LocalizationManager provides interfaces for retrieving and setting the active language. These services form the foundation for version tracking, safe concurrent installations, file management, and dynamic language switching.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/services · high confidence

The \feature/details/data\ module introduces the backend logic for the app details view, including a new Youdao translation provider alongside existing services, an installation manager that validates APKs and tracks app states, and a markdown preprocessor that handles localized READMEs and complex formatting. Dependency injection is configured via \SharedModule\ to wire these repositories and system components together.

feature/details/data · high confidence

The data layer now includes a comprehensive set of new mappers in the \core/data/mappers\ package to support recently added features. \AnnouncementMapper\ and \WhatsNewEntryMapper\ translate backend and local DTOs into domain models for in-app announcements and what's-new content. \ExternalMatchMappers\ handle the serialization and deserialization of data for the new backend-based app matching service, including installer kind and match source conversions. \BackendRepoMapper\ and \GithubRepoMapper\ map repository summary data from both the new backend API and the GitHub network layer. Additionally, \ObtainiumExportMapper\ enables the export of installed apps to the Obtainium JSON format, while \FavouriteRepoMappers\, \StarredRepoMapper\, \InstalledAppsMappers\, \UpdateHistoryMapper\, and \UserProfileMappers\ provide the necessary data binding for their respective domain entities.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/mappers · high confidence

The data layer now includes new repository implementations for managing user preferences and state: TweaksRepositoryImpl handles settings (themes, installer types, update checks) and has migrated storage from DataStore to KSafe for encryption, including a background migration for existing users. AnnouncementsCacheStoreImpl similarly moved cached announcement payloads to KSafe. Additional repositories have been added to support new features: HiddenReposRepositoryImpl and SeenReposRepositoryImpl track user visibility preferences, FavouritesRepositoryImpl manages starred repositories with install status, HostTokenRepositoryImpl stores per-host authentication tokens securely, ExternalImportRepositoryImpl handles scanning and linking of external apps, CacheRepositoryImpl manages app cache size and clearing, and UserSessionRepositoryImpl handles login state and session expiration logic.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository · high confidence

The data module now includes a comprehensive set of new DTOs (e.g., \BackendRepoResponse\, \AnnouncementDto\, \MirrorEntry\) to support fetching repository data, announcements, and mirror configurations from a backend API. Additionally, new service managers (\DhizukuServiceManager\, \RootServiceManager\, \ShizukuServiceManager\) and an \AndroidInstallerStatusProvider\ have been added to handle privileged installation permissions and status tracking, while a \SlowDownloadDetectorImpl\ and \ManifestHintExtractor\ enhance download reliability and external app matching.

data · high confidence

The domain layer now includes a comprehensive set of new data models to support account authentication (HostNames, HostToken, UserProfile), detailed APK inspection (ApkInspection, ApkPackageInfo), and robust installation tracking (InstalledApp, DeviceApp, InstallerAttribution). Repository discovery is enhanced with models for GitHub-specific data (GithubRelease, GithubRepoSummary) and multi-source support via RepositorySource (GitHub, Forgejo). Additional models cover system scanning (ScanResult, ExternalAppCandidate), transfer/export formats (ExportedApp, ObtainiumApp), and settings (AppLanguages, ProxyConfig), providing the structural foundation for these features.

domain · high confidence

The app now includes a complete UI for the external import wizard, introducing new screens and components to guide users through linking installed apps to repositories. This includes a permission rationale screen that requests package visibility access, a progress screen with a skip option, a candidate list using scrollable cards with expandable search and link actions, a summary screen showing auto-linked counts and labels with an undo option, a completion toast, and an import proposal banner. The wizard also supports manual entry and displays repo details like owner, stars, and source host (including Codeberg and ForgeJo).

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/import/components · high confidence

The app now includes a dedicated UI for importing external repositories, featuring a multi-phase wizard that guides users through scanning, permission requests, and an auto-import summary screen. Users can review imported items in a list, search for specific packages, and undo actions via snackbar notifications. The interface respects system reduced-motion preferences and includes options to skip lengthy scans or remaining items during the review phase.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/import · high confidence

The feedback experience now uses a bottom-sheet form that lets users select a category (Bug, Feature Request, Change Request, or Other) and a topic, then fills in category-specific fields such as steps to reproduce or proposed solutions. Users can attach a diagnostics summary (app version, platform, locale, theme) and send their feedback via email or GitHub.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/components · high confidence

The import feature now exposes a structured state machine and UI model types to guide the user through the import process. A new \ImportPhase\ enum defines the progression from idle and permission requests through scanning, auto-importing, summary review, and completion. Additionally, \SuggestionChipTone\ controls the visual styling of suggestion chips (primary vs. muted), and \SuggestionSource\ categorizes where import suggestions originate (manifest, search, fingerprint, manual, or starred).

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/import/model · high confidence

This change introduces a comprehensive set of new Room DAOs in the data layer to support expanded app tracking and user customization features. InstalledAppDao now handles granular update settings, including per-app toggles for update checks and pre-release visibility, asset filtering, variant selection, and release skipping. Supporting this, new DAOs manage user preferences and history: CacheDao provides a robust caching layer with expiration and prefix-based operations; HiddenRepoDao and SeenRepoDao allow users to hide or track repositories; SearchHistoryDao and UpdateHistoryDao persist recent searches and update events; ExternalLinkDao manages external link states; and FavoriteRepoDao and StarredRepoDao handle repository favorites with install status synchronization. SigningFingerprintDao tracks app signatures for security verification.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db/dao · high confidence

The mirror selection screen now features a dedicated picker interface that separates mirrors into official and community sections, displays real-time status indicators via colored dots, and allows users to add and configure their own custom mirror endpoints through a new dialog.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/mirror · high confidence

The app now displays dedicated overlay dialogs to handle API rate limits and session expiration. The RateLimitDialog informs users when their GitHub API quota is exhausted, showing the reset time and offering a sign-in option for authenticated users to gain higher limits, while unauthenticated users see the free-tier limit. The SessionExpiredDialog appears when a user's session has ended, prompting them to sign in again or continue as a guest. Both dialogs utilize the new personality design system for consistent styling.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/components · high confidence

Users can now view a dedicated list of applications they have previously chosen to skip updating. This new screen displays the app name and the specific version tag that was skipped (along with the currently installed version if applicable). From this list, users can choose to 'unskip' an update, which re-enables update notifications for that specific application; success or failure of this action is communicated via on-screen toasts.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/skipped · high confidence

The search domain layer now includes new domain models for programming languages, sorting criteria (by stars, forks, match, recently updated, or released), and sort direction (ascending/descending). It also introduces repository interfaces for managing search history and performing repository searches with support for platform, language, and sorting filters, as well as a new 'Explore from GitHub' capability.

feature/search/domain · high confidence

The Home screen presentation has been rebuilt to support a tabbed chart view (Trending, Releases, Popular) via HomeChartTabs, allowing users to switch between discovery categories. A new platform picker (HomePlatformPicker) enables filtering repositories by platform, and a context-aware actions sheet (RepositoryActionsSheet) provides options to share, open on GitHub, toggle view status, or hide repositories. The layout now includes dedicated category list views (CategoryListRoot) for each chart tab, featuring infinite scroll and platform-specific UI treatments.

feature/home/presentation · high confidence

The Search screen presentation layer has been rebuilt to support a richer set of search capabilities. Users can now filter results by source (GitHub, Codeberg, or custom Forgejo), platform, and programming language via a new SearchFiltersSheet. Sorting options have been expanded to include 'Recently Updated' and 'Recently Released' in addition to stars and forks, with support for ascending/descending order. The interface also introduces a SearchHistorySection for quick access to recent queries, GitHub link detection for clipboard integration, and arrow-key navigation for scrollable lists.

feature/search/presentation · high confidence

The app now uses a new SilentInstallerDispatcher to handle APK installations via elevated privilege backends (Shizuku, Dhizuku, and Root) in addition to the standard Android installer. This allows silent installs to proceed without requiring the user to grant 'Install unknown apps' permissions for each app, with automatic fallback to the standard installer if silent methods fail or are unavailable. The dispatcher also handles silent uninstallation through these backends and includes retry logic for Dhizuku when user action is required.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer · high confidence

The domain layer now supports linking device apps to repository releases with detailed variant tracking (including asset name, sibling count, preferred variant, and glob patterns) and provides capabilities to export and import app configurations. Import functionality detects the source format, supporting both native and Obtainium JSON structures, enabling users to migrate or backup their app tracking settings.

feature/apps/domain/src/commonMain/kotlin/zed/rainxch/apps/domain · high confidence

The application now uses a unified Koin initialization process that explicitly wires all ViewModels and core modules. This change consolidates dependency injection by defining specific modules for main app logic, view models, and 'What's New' content, ensuring that features like repository details, search, and user profiles are correctly instantiated with their required repositories and use cases.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/di · high confidence

The application's data layer now initializes its core infrastructure through a new Koin module that wires up essential services. This includes configuring the HTTP client with timeout and default request settings, setting up the Room database with DAOs for caching, search history, and repository metadata, and binding repository implementations such as MirrorRepository, ProxyRepository, and AnnouncementsRepository to their respective interfaces. Users benefit from a more robust and structured data access layer that supports features like mirror selection, proxy configuration, and announcement caching.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/di · high confidence

This change introduces a suite of new Gradle convention plugins in the build-logic module to standardize and modularize the project's build configuration. For native Android applications, the new plugins enforce a consistent namespace, centralize SDK and version code management via version catalogs, and enable ProGuard and resource shrinking for release builds. For Compose Multiplatform modules, the plugins automatically apply necessary Kotlin and Compose plugins, configure target-specific dependencies (such as Koin and Jetbrains Compose libraries), and set up shared dependencies like kotlinx-serialization and Room with KSP. Additionally, a new Ktlint plugin is added to enforce code formatting and linting during the build process.

build-logic/convention/src/main/kotlin · high confidence

The authentication domain module has been restructured into a new, modular package that defines the core \AuthenticationRepository\ interface. This interface exposes flows for access tokens and methods for initiating device flows, polling for tokens (supporting both direct and backend-proxy paths via the new \AuthPath\ enum), signing in with Personal Access Tokens, and handling web OAuth registration and handoffs. This change establishes the foundational domain contracts for the app's authentication logic, separating it from previous implementations.

feature/auth/domain · high confidence

The build system now uses convention plugins in the build-logic module to standardize project setup. These plugins automatically configure Android SDK versions, enforce Java 17 compatibility, set up Kotlin Multiplatform targets (Android and JVM), enable Jetpack Compose with the BOM, and apply specific Kotlin compiler flags. This centralizes build logic, ensuring consistent compilation and dependency management across all modules without manual configuration in each project.

build-logic/convention/src/main/kotlin/zed · high confidence

A change to existing behaviour in composeApp/src/jvmMain/resources — 1 commit, 3 files.

composeApp/src/jvmMain/resources · medium confidence · unverified

A change to existing behaviour in composeApp/release — 46 commits (4 fixs), 2 files.

composeApp/release · medium confidence · unverified

The app now includes comprehensive ProGuard/R8 rules to ensure code shrinking and obfuscation work correctly with the Kotlin Multiplatform, Compose, Ktor, Room, and Koin dependencies, while specifically preserving classes required for the Shizuku silent installer feature. Additionally, a Kotzilla SDK configuration file has been added to enable crash reporting and analytics.

composeApp · high confidence

The Android application entry point now explicitly manages critical startup tasks, including the creation of dedicated notification channels for updates, services, and downloads, as well as the dynamic registration of a package event receiver to monitor system install changes. It also initializes background update scheduling based on user tweaks, starts a download notification observer, and performs initial setup tasks such as external scan scheduling, signing seed synchronization, and proxy bootstrapping, ensuring these operations run in isolated scopes to prevent startup failures from blocking the entire application.

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/app · high confidence

The Android entry point now handles incoming intents for both deep links (via ACTION\_VIEW) and shared content (via ACTION\_SEND), resolving them to navigate to specific repository details. Additionally, the app dynamically switches its display language in real-time; it reads the initial language preference with a timeout to avoid startup delays and listens for changes, automatically restarting the activity when the user updates their language setting.

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore · high confidence

The Android presentation module now explicitly enables pull-to-refresh functionality. A new platform-specific utility confirms that pull-to-refresh is supported on Android, allowing the UI layer to activate this interaction pattern, while the corresponding JVM/desktop implementation disables it.

core/presentation/src/androidMain · high confidence

This change introduces Android-specific implementations for three utility interfaces used in the import feature: PackageVisibilityRequester, ReducedMotionProvider, and SdkLevelProvider. The PackageVisibilityRequester now checks if the app has sufficient package visibility permissions on Android R (API 30+) by verifying if at least 30 packages are visible, while ReducedMotionProvider reads the system's animator duration scale to respect user accessibility preferences, and SdkLevelProvider exposes the current Android SDK version.

feature/apps/presentation/src/androidMain/kotlin/zed/rainxch/apps/presentation/import · high confidence

The announcements cache is now persisted in its own separate DataStore file rather than sharing a generic storage instance. This separation ensures that announcement data is isolated from other app preferences, which can improve performance and reliability by reducing contention and allowing the cache to be managed independently.

_core/data/src/androidMain/kotlin/zed/rainxch/core/data/local/data\_store, core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/data\store · high confidence

The announcements cache is now stored in its own dedicated DataStore instance rather than sharing a general preferences store. This new instance uses a specific file path located in the application's data directory, and includes logic to automatically migrate existing cache data from a temporary location if necessary, ensuring data persistence across sessions on desktop platforms.

_core/data/src/jvmMain/kotlin/zed/rainxch/core/data/local/data\store · high confidence

The presentation layer now centralizes all external links (privacy policy, source code, social channels, website, and email) in a new Constants object, ensuring consistent URLs across the app. Additionally, a new TweaksDeepLinkBus utility has been introduced to manage deep-link events, specifically allowing the app to request and consume feedback prompts via a shared flow.

feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/utils · high confidence

The application now uses a centralized \App\ composable in the main module to orchestrate the user interface, replacing scattered entry points. This change introduces a unified theming system that supports distinct 'personalities' (Classic and Manga) with configurable accents, paper styles, and AMOLED dark modes, all applied via a \PersonalityTheme\ wrapper. Navigation is managed through a single \AppNavigation\ component driven by a central \MainViewModel\, which aggregates state for user sessions, rate limits, and settings. The shell also handles critical user-facing dialogs—such as rate-limit warnings, session expiration, and the 'What's New' sheet—ensuring they are displayed contextually (e.g., suppressing rate-limit dialogs on the auth screen). Additionally, desktop-specific features like keyboard navigation shortcuts and deep-link handling are integrated directly into this main entry point.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore · high confidence

The local database initialization logic has been updated to explicitly handle schema downgrades by destroying and recreating all tables. This ensures that if the app is rolled back to a version with an older database schema, the existing data is cleared rather than causing a crash or corruption, providing a safer recovery path for users during version downgrades.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/local/db · high confidence

The local Room database schema has been upgraded to version 18, introducing support for new data models including hidden repositories, search history, signing fingerprints, and external links. This change adds corresponding Data Access Objects (DAOs) and entity classes for these features, enabling the application to persist user preferences for hiding seen repositories, tracking search history, and managing app signing verification data alongside existing installed apps and favorites.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db · high confidence

The local Room database has been migrated through seventeen steps (versions 1 to 18), introducing significant structural changes to support new app features. New tables include \starred\_repos\, \cache\_entries\, \seen\_repos\, \search\_history\, \external\_links\, \signing\_fingerprints\, and \hidden\_repos\. The existing \installed\_apps\ table has been extended with numerous columns to track version details (\installedVersionName\, \latestVersionCode\), release preferences (\includePreReleases\, \assetFilterRegex\, \fallbackToOlderReleases\), asset selection (\preferredAssetVariant\, \assetGlobPattern\, \pickedAssetIndex\), installation state (\pendingInstallFilePath\, \pendingInstallVersion\), security verification (\signingFingerprint\, \sourceHost\), and user controls (\skippedReleaseTag\).

core/data/src/androidMain/kotlin/zed/rainxch/core/data/local/db/migrations · high confidence

On Desktop, changing the app language now triggers a best-effort restart: the current process exits and a new instance is launched with the same command and arguments. If the process command cannot be determined or the relaunch fails, the app simply exits without restarting, and these events are logged via Kermit.

feature/tweaks/presentation/src/jvmMain · high confidence

The installed app icon component now safely resolves icons from both installed packages and local APK files, ensuring that a fallback placeholder is displayed if resolution fails. The implementation wraps icon loading in try-catch blocks to prevent crashes from PackageManager exceptions and includes compatibility handling for Android 13+ when accessing APK archive info.

feature/apps/presentation/src/androidMain/kotlin/zed/rainxch/apps/presentation/components · high confidence

The download process now uses a new MultiSourceDownloader that attempts to fetch files via a configured mirror first, falling back to a direct GitHub download if the mirror fails or is unavailable. This change addresses a race condition that could corrupt the destination file when both mirror and direct downloads were active simultaneously, ensuring data integrity. Additionally, mirrors that do not support release assets are automatically skipped.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/download · high confidence

This change introduces a new layer of UI models and corresponding mappers within the apps presentation module, bridging the gap between domain data and the user interface. New mapper files (AppItemMapper, DeviceAppMapper, GithubAssetMapper, GithubRepoInfoMapper, and InstalledAppMapper) convert domain entities like InstalledApp, DeviceApp, and GithubAsset into their respective UI counterparts (InstalledAppUi, DeviceAppUi, etc.). Specifically, AppItemMapper adds logic to compute busy states, version labels, and skip capabilities for app items, while other mappers handle straightforward property mapping for device apps, GitHub assets, and repository info. This refactoring supports the improved installed apps UI by providing a clean separation between domain logic and presentation data.

feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/mappers · high confidence

The application now uses the Kermit library for logging, replacing the previous implementation. This change introduces a new \KermitLogger\ object that implements the \KomiStoreLogger\ interface, delegating debug, info, warn, and error messages to Kermit's \Logger\. It also supports tagged logging via a \TaggedKermitLogger\ wrapper, allowing logs to be filtered or identified by specific tags.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/logging · high confidence

The JVM module now initializes the local Room database using a dedicated file path derived from DesktopAppDataPaths, ensuring data persists across sessions. The initialization process includes an automatic migration step that moves existing database files (github\_store.db, .wal, .shm) from a temporary location to the new persistent directory if necessary. The database builder is configured to use the BundledSQLiteDriver and falls back to destructive migration if schema changes are incompatible.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/local/db · high confidence

The app now stores GitHub device tokens using the KSafe secure storage library instead of the previous DataStore-based implementation. This change improves security by leveraging KSafe's encryption capabilities. To ensure a seamless transition, the system automatically detects and migrates existing tokens from the legacy DataStore storage to KSafe on first access, preserving user sessions without requiring re-authentication. The migration is handled transparently in the background, and the new storage layer includes robust error handling to prevent crashes if the secure storage is unavailable.

_core/data/src/commonMain/kotlin/zed/rainxch/core/data/data\source · high confidence

The mirror repository implementation has been updated to migrate user preferences (such as the selected mirror and custom templates) from the legacy DataStore to KSafe for improved security. Additionally, the system now includes a bundled list of community mirrors (e.g., fastly.jsdelivr.net, ghfast.top) that serve as a fallback if the remote catalog is unavailable or fails to load, ensuring users always have access to mirror options even in offline or degraded network conditions.

core/data/src/commonMain/kotlin/zed/rainxch/core/data/mirror · high confidence

Added AIDL definitions for \IDhizukuInstallerService\ and \IShizukuInstallerService\ to enable silent APK installation via the Shizuku and Dhizuku backends. The Dhizuku interface now accepts \expectedPackageName\ and \expectedVersionCode\ parameters alongside the \ParcelFileDescriptor\, allowing the installer to verify the package identity and version during installation, while the Shizuku interface passes the \installerPackageName\ to support silent installation paths.

core/data/src/androidMain/aidl · high confidence

The authentication experience has been restructured into a new presentation module that introduces a unified login screen with animated transitions and a redesigned layout. This update adds support for the GitHub Device Authorization flow, allowing users to sign in via a device code, and implements a deep-link bus to handle OAuth callbacks and browser-based authentication handoffs. The changes also include a new PKCE generator for secure token exchange and a dedicated deep-link event system to manage navigation states during the login process.

feature/auth/presentation · high confidence

Desktop application settings and data are now stored in platform-standard application data directories (e.g., \~/Library/Application Support on macOS, %APPDATA% on Windows, and \~/.local/share on Linux) instead of the user's home root or temporary directories. To ensure existing users retain their configuration, the system automatically migrates legacy data from the previous location (\~/.eu\_anifantakis\_ksafe) and temporary files into the new persistent storage structure during the first launch.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/local · high confidence

The in-app What's New experience has been updated to use a new sheet-based UI component that displays version details and release notes in a structured layout. Content is now loaded from localized JSON files, allowing the app to present release notes in the user's preferred language (falling back to English) and supporting multiple language variants. The dialog includes a dismiss action and an optional history view, providing a cleaner and more accessible way to review recent app updates.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/whatsnew · high confidence

The app navigation has been restructured to support adaptive layouts, featuring a dedicated DesktopSidebar for desktop devices and a BottomNavigation bar for mobile. This change introduces several new screens and routes, including Apps, Favourites, Starred Repositories, Recently Viewed, Tweaks, and an External Import flow. The Details screen now supports nested navigation to About and What's New sections with slide animations, and the Profile section has been expanded to include Announcements, Whats New history, and direct links to developer profiles. Navigation state management has been updated to use class-based route matching and improved transition animations.

composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation · high confidence

The Shizuku installer service implementation has been updated to perform APK installation and uninstallation via shell commands (pm install/uninstall) rather than reflection-based framework APIs. This change introduces explicit timeouts (120 seconds for installation, 30 seconds for uninstallation) to prevent hanging operations, and ensures that the installer package name is correctly passed to the system package manager during installation.

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku · high confidence

The desktop-specific implementation of the external app scanner now returns empty results and assumes all permissions are granted. This means that on desktop platforms, the application will no longer attempt to detect or list installed external applications, effectively disabling this feature for the desktop user experience.

core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/external · high confidence

The Linux application now uses a custom bash launcher script to bypass a crash in the native launcher caused by glibc 2.42+ compatibility issues. This new launcher directly invokes the bundled JVM, ensuring the app starts correctly on modern distributions like Fedora 43 and Ubuntu 26.04. Additionally, the launcher includes a fallback mechanism to use a system Java installation if the bundled \bin/java\ is missing from the package, resolving issues where the runtime binary was stripped during packaging.

packaging/linux · high confidence

The project now includes a Gradle wrapper configuration file that specifies the use of Gradle version 8.14.3. This ensures that all developers and build environments use the same Gradle distribution, improving build consistency and reproducibility by automatically downloading the required version if it is not already present.

gradle · high confidence

The local Gradle wrapper cache now includes the lock file (.lck) and partial download file (.part) for the Gradle 8.14.3 binary distribution. This indicates that the system is preparing to download or has started downloading the Gradle 8.14.3 distribution, which will be used for building the project.

.gradle-local · high confidence

The build system has been restructured to use a centralized version catalog (gradle/libs.versions.toml) and a new build-logic module containing convention plugins. This change introduces a modular architecture with separate modules for core features (domain, data, presentation) and specific app features (apps, auth, details, etc.), standardizing dependency management and build configuration across the project.

(dependencies) · high confidence

Added build directory to gitignore; Documentation of Home feature architecture and behavior.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 56 (+12.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 83 (+0.2)
• Architecture 94 → 84 (-10.0)
• Maturity 50 → 64 (+13.8)
• Readiness 23 → 47 (+23.9)
• Security 50 → 55 (+4.6)
• Domain Modelling 100 → 70 (-30.3)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (core/data/src/jvmMain/kotlin/zed/rainxch/core/data/utils/DesktopAppLauncher.kt)
• Duplicated block (10 lines × 2) (feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt)
• Duplicated block (11 lines × 2) (core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt)
• Duplicated block (11 lines × 2) (core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopDownloader.kt)
• Duplicated block (11 lines × 2) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/network/GitHubAuthApi.kt)
• Duplicated block (11 lines × 2) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/network/WebAuthApi.kt)
• Duplicated block (11 lines × 2) (feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/repository/DetailsRepositoryImpl.kt)
• Duplicated block (11 lines × 2) (feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data_source/impl/CachedRepositoriesDataSourceImpl.kt)
• Duplicated block (12 lines × 2) (composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation/DesktopSidebar.kt)
• Duplicated block (12 lines × 2) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/dividers/KomiDivider.kt)
• Duplicated block (12 lines × 2) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt)
• Duplicated block (12 lines × 2) (feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/repository/DetailsRepositoryImpl.kt)
• Duplicated block (12 lines × 2) (feature/dev-profile/presentation/src/commonMain/kotlin/zed/rainxch/devprofile/presentation/components/ProfileInfoCard.kt)
• Duplicated block (12 lines × 2) (feature/repo-pages/data/src/commonMain/kotlin/zed/rainxch/repopages/data/repository/RepoPagesRepositoryImpl.kt)
• Duplicated block (12 lines × 2) (feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt)
• Duplicated block (12 lines × 2) (feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/hosttokens/HostTokensViewModel.kt)
• Duplicated block (13 lines × 2) (core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/StarredRepositoryImpl.kt)
• Duplicated block (13 lines × 2) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/bars/KomiBottomBar.kt)
• …and 84 more

• AndroidDownloader.download (cognitive 18) (core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt)
• AndroidDownloader.download (cyclomatic 17) (core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt)
• AppHeaderKt.AppHeader (cognitive 23) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/components/AppHeader.kt)
• AppHeaderKt.AppHeader (cyclomatic 22) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/components/AppHeader.kt)
• AppItemCardKt.AppItemCard (cognitive 22) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/components/AppItemCard.kt)
• AppItemCardKt.AppItemCard (cyclomatic 30) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/components/AppItemCard.kt)
• AppNavigationKt.AppNavigation (cognitive 20) (composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation/AppNavigation.kt)
• AppNavigationKt.AppNavigation (cyclomatic 19) (composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation/AppNavigation.kt)
• AppsRepositoryImpl.detectFormat (cognitive 19) (feature/apps/data/src/commonMain/kotlin/zed/rainxch/apps/data/repository/AppsRepositoryImpl.kt)
• AppsRootKt.AppsScreen (cognitive 27) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsRoot.kt)
• AppsRootKt.AppsScreen (cyclomatic 16) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsRoot.kt)
• AppsViewModel.onAction (cyclomatic 68) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt)
• AppsViewModel.updateSingleApp (cognitive 31) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt)
• AppsViewModel.updateSingleApp (cyclomatic 32) (feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt)
• AssetVariant.extractBaseStem (cognitive 21) (core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/utils/AssetVariant.kt)
• AssetVariant.extractTokens (cognitive 21) (core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/utils/AssetVariant.kt)
• AuthenticationRepositoryImpl.awaitDeviceToken (cognitive 31) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/repository/AuthenticationRepositoryImpl.kt)
• AuthenticationRepositoryImpl.awaitDeviceToken (cyclomatic 20) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/repository/AuthenticationRepositoryImpl.kt)
• Boundary-crossing change coupling: AppNavigation.kt ↔ ProfileAction.kt (composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/navigation/AppNavigation.kt)
• Boundary-crossing change coupling: MainViewModel.kt ↔ ProfileState.kt (composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainViewModel.kt)
• …and 407 more

• 2 commits — 1 feature/other, 1 fixes

• (root) — 1 commit
• feature/details — 1 commit

• fix: fix(ui): align asset card spacing and animate picker height changes (#938)
• change: Update GitHub org paths to komi-store (#956)

• Containers 0 added · 0 removed · contexts 4 added · 0 removed · edges 5 added · 0 removed

• composeApp
• data
• domain
• presentation

• composeApp → data
• composeApp → domain (coupling)
• composeApp → presentation (coupling)
• data → domain (coupling)
• presentation → domain (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

kurikomi-labs/komi-store was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.