Skip to content
CAI
Software that uses CAICheck a score

kurikomi-labs/komi-store

68.2

Adequate · 13 November 2026

104.2k

lines of production code

Kotlin

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add JVM-specific network implementation with OS trust store and proxy support

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

Add Shizuku-based silent APK installation and uninstallation

The app now supports installing and uninstalling APKs silently via the Shizuku framework. This change introduces a new service implementation that executes system package manager commands through Shizuku, allowing for background installation without user interaction. It includes logic to detect Shizuku availability, request necessary permissions, and manage the service lifecycle with specific timeouts for install (120s) and uninstall (30s) operations.

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

The search domain layer now includes the \ExploreResult\ data class to represent paginated GitHub repository summaries and the \SearchSource\ sealed interface to distinguish between GitHub and Forgejo-based sources (including Codeberg). These models provide the underlying data structures required for the new "Explore from GitHub" functionality and support for additional code forges in search operations.

feature/search/domain · high confidence

Add download count and release date to repository summaries

The home feature's data layer now maps backend repository responses to cached summaries that include the download count and the latest release date for the selected platform. These fields are passed through to the domain model, making them available for display in the UI.

feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/mappers · high confidence

Add logout event definitions to the Profile feature

The Profile feature presentation layer now defines a sealed interface for user actions and outcomes, specifically introducing events to handle the result of a logout operation. Users will now have explicit handling for successful logouts and error states, allowing the UI to react appropriately to the completion or failure of the logout process.

feature/profile/presentation · high confidence

Add ownership verification badge to favorite repository items

The FavouriteRepositoryItem component now displays a verified checkmark icon next to the repository owner's name when the current user is the owner of the repository. This visual indicator helps users quickly identify their own repositories within their favorites list.

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

Add release category model for filtering

A new ReleaseCategory enum has been introduced to the domain model, defining STABLE, PRE\_RELEASE, and ALL categories. This model provides the underlying data structure required to support release category filtering and version picker functionality within the application.

feature/details/domain/src/commonMain/kotlin/zed/rainxch/details/domain/model · high confidence

Added JVM-specific UI components for app icons and scrollbars

This change introduces two new platform-specific components for the desktop (JVM) target: \InstalledAppIcon\, which renders a generic placeholder image for application icons, and \ScrollbarContainer\, which wraps list and grid content with a styled vertical scrollbar. The scrollbar implementation supports \LazyListState\, \LazyGridState\, and \LazyStaggeredGridState\, providing custom adapters to calculate scroll offsets and content size for grids and staggered grids, ensuring consistent scrolling behavior across different list types on desktop.

core/presentation/src/jvmMain/kotlin/zed/rainxch/core/presentation/components · high confidence

Added UI-to-domain mappers for search filters and sorting

The search presentation layer now includes dedicated mapper classes that convert UI selection models into domain models for programming languages, search sources (including Codeberg and custom Forgejo instances), and sort criteria (such as Recently Updated and Recently Released). This ensures that user selections in the search interface are correctly translated into the underlying domain logic.

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

Added placeholder for desktop external installer selection

A new \DesktopExternalInstallerRepository\ implementation has been added to the core data layer for the JVM target. Currently, it implements the \ExternalInstallerRepository\ interface but returns an empty list of available installers, serving as a stub to support the upcoming feature of handing APKs to a chosen third-party installer on desktop platforms.

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

Added utility interfaces and providers for import feature

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

Android app initialization and local network access handling

The Android application module now initializes core services including crash logging, diagnostic session capture, and background update scheduling. It introduces a new local network permission flow for Android 17 (API 37) that detects when proxy, forge, or translation hosts are on the local network and requests the ACCESS\_LOCAL\_NETWORK permission only when needed. The app also applies display mode preferences and system bar appearance settings during startup.

androidApp/src/main/kotlin · high confidence

Android app scanner now classifies install sources and computes signing fingerprints

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

Android background update and installation orchestration

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

Android network layer adds streaming SHA-256 verification and dynamic proxy support

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

Android platform dependency injection module introduced

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

Android-specific UI component implementations

This change introduces Android-specific implementations for core presentation components. The new InstalledAppIcon component displays application icons by resolving them from the installed package or an APK file path, falling back to a generic avatar if unavailable. Additionally, ScrollbarContainer is implemented for Android as a no-op wrapper, meaning scrollbars are not rendered on this platform.

core/presentation/src/androidMain/kotlin/zed/rainxch/core/presentation/components · high confidence

Classic personality now supports dynamic wallpaper colors on Android

The Classic personality theme now adapts to the device's wallpaper colors on Android 12 (API 31) and higher. This is implemented via new platform-specific files that enable dynamic color schemes on Android while providing a null fallback for JVM targets, ensuring the theme remains consistent across platforms without breaking on older Android versions or non-Android environments.

core/presentation/src/androidMain/kotlin/zed/rainxch/core/presentation/personality, core/presentation/src/jvmMain/kotlin/zed/rainxch/core/presentation/personality · high confidence

Configurable translation provider system with multiple backend support

The repository details data layer now supports a configurable translation provider system, allowing users to select from Google, DeepL, LibreTranslate, Microsoft, Youdao, and other translation services. This change introduces new translator implementations (DeeplTranslator, GoogleTranslator, LibreTranslator, MicrosoftTranslator, YoudaoTranslator) and a TranslationRepositoryImpl that manages provider selection, caching, and text protection (preserving code blocks and links). Users can now choose their preferred translation backend via tweaks settings, with fallback and error handling for each provider.

feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/repository · high confidence

Database schema expanded with 21 migration steps

The local database now supports a significantly richer schema for installed applications and repository management. New columns have been added to the \installed\_apps\ table to track version details, asset preferences, signing fingerprints, release timestamps, and pending installation states. Additionally, new tables for \starred\_repos\, \seen\_repos\, \search\_history\, \external\_links\, \signing\_fingerprints\, and \hidden\_repos\ have been introduced, along with a \cache\_entries\ table, enabling features like search history, repository hiding, and external link tracking. A complete chain of 21 migrations (versions 1 through 21) is provided to ensure existing data is preserved and upgraded smoothly.

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

Desktop app launching, browser opening, and file sharing capabilities

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

Desktop platform support for downloads and installations

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

Desktop stability, deep linking, and window state persistence

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

Details screen receives a complete UI and state overhaul with new management features

The Details screen has been rebuilt to support a richer set of app management capabilities and a more expressive interface. Users can now uninstall apps, unlink external app associations, and handle downgrade or signing-key warnings directly from the details view. The release selection experience is enhanced with a version picker, release category filtering (stable vs. pre-release), and platform-specific asset grouping. Content sections like 'About' and 'What's New' are now expandable and support automatic translation. The UI also includes an APK inspection tool, improved error states, and better handling of multi-flavor installed apps.

feature/details/presentation/src/commonMain · high confidence

Favourites screen supports search, sorting, and owner badges

The Favourites presentation layer has been rebuilt to include a search bar that filters repositories by name, owner, description, or language, and a sort menu allowing users to order their favourites by Recently Added or Name (ascending). The repository list items now display a checkmark badge when the current user owns the repository, and the view model persists the chosen sort rule. Additionally, the screen supports importing starred repositories and navigating to developer profiles.

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

Flatpak packaging support for Linux

Komi Store can now be packaged and distributed as a Flatpak (app ID com.kurikomi.komistore). This adds a sandboxed Linux build that bundles the JetBrains Runtime, uses an offline Maven repository for reproducible builds, and restricts file access to the user's Downloads folder (manual installation is required for downloaded releases). The packaging includes the Flatpak manifest, desktop entry, AppStream metadata, and scripts to strip Android-specific build targets for the Linux-only environment.

packaging · high confidence

Home screen now supports repository visibility tracking and contextual actions

The Home feature now allows users to mark repositories as seen or unviewed, hide them from the discovery feed, and share repository links via a new bottom-sheet action menu. This is enabled by a new HomeAction interface and HomeState model that track seen/hidden status and platform selection, wired into the HomeViewModel to manage caching and repository filtering, and presented via a RepositoryActionsSheet component accessible on long-press.

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

Implement developer profile data repository with backend fallback and concurrency controls

The data layer for the developer profile feature now includes a new repository implementation that fetches user profiles, contribution calendars, and repositories. Profile and repository data retrieval prioritizes a backend API, automatically falling back to the GitHub API if the backend is unavailable or rate-limited. Repository fetching is optimized with pagination and concurrent processing (using a semaphore) to handle multiple repositories efficiently, while contribution data is fetched from a dedicated third-party API.

feature/dev-profile/data · high confidence

Implement search history persistence and new network models

Users can now have their search queries saved locally, allowing them to view and manage their recent search history through the new SearchHistoryRepositoryImpl. Additionally, the search data layer now includes new DTOs (AssetNetworkModel, GithubReleaseNetworkModel) to support richer release data handling in search results.

feature/search/data/src/commonMain/kotlin/zed/rainxch/search/data/repository · high confidence

Import starred repositories by username

Users can now import their starred repositories from a GitHub username. This feature adds a new import flow where users enter a username, view the resulting list of starred repositories (including details like description, language, and star count), and selectively add them to their favorites or add all at once. The UI includes search filtering within the imported list and handles errors gracefully.

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

Improved README localization and Markdown preprocessing

The app now uses a new ReadmeLocalizationHelper to intelligently search for localized README files (e.g., README.zh.md, README\_zh.md) across standard directories like .github and docs, falling back to English or the default README. Additionally, Markdown rendering has been enhanced with a new preprocessing step that resolves relative image and link URLs correctly, strips out badge images to improve performance, and better handles reference-style links and details/summary blocks.

feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/utils · high confidence

Initial project scaffolding and documentation

The repository has been initialized with the core project structure, including the Kotlin Multiplatform application modules (\composeApp\, \androidApp\), Gradle wrapper scripts, and essential configuration files like \.editorconfig\ and \.gitignore\. This change also introduces comprehensive project documentation, including \README.md\ with download links and feature overviews, \CONTRIBUTING.md\ with development guidelines, \AGENTS.md\ for AI coding assistants, and standard policy files like \CODE\_OF\_CONDUCT.md\ and \SECURITY.md\.

(repo-wide) · high confidence

Introduce Apps presentation layer with import, sorting, and state management

The Apps feature now includes its own presentation layer, introducing the AppsViewModel and associated event interfaces to manage the installed apps list, external import flows, and starred picker navigation. This change adds support for sorting apps by repository, handling pending external imports, and managing UI states such as error and success notifications, laying the groundwork for the apps list and import functionality.

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

Introduce Developer Profile feature with repository filtering and sorting

Users can now view a developer's profile, including their contribution calendar and a list of repositories. The repository list supports filtering (by releases, installable assets, installed status, or favorites) and sorting (by update date, stars, or name), with 'With Releases' set as the default filter. The UI includes keyboard navigation for lists and optional scrollbar support on desktop platforms.

feature/dev-profile/presentation/src/commonMain/kotlin/zed/rainxch/devprofile/presentation · high confidence

Introduce Dhizuku silent installer service with robust install verification

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

Introduce Recently Viewed repositories screen

A new 'Recently Viewed' feature has been added, allowing users to browse a history of repositories they have previously visited. The presentation layer displays these items in a scrollable, adaptive staggered grid, with each card showing the repository name, owner, description, primary language, and the time it was viewed. Users can navigate to a repository's details or the developer's profile directly from the list, and they have the ability to remove individual items or clear the entire history.

feature/recently-viewed/presentation/src · high confidence

Introduce RootServiceManager for silent root detection and root-based package management

Added RootServiceManager to handle root access detection and silent APK installation/uninstallation via the root shell. The manager persists root grant status to avoid re-prompting users on every app launch, ensuring a smoother experience when root is already granted. It supports silent installs using the pm command with optional installer package names and validates package names against a strict pattern to prevent injection. Root status is exposed via a StateFlow for UI binding.

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

Introduce Starred Picker for APK-shipping repositories

A new Starred Picker screen has been added to the Apps feature, allowing users to browse their starred GitHub repositories and identify which ones ship Android APKs. The interface displays candidate repositories with details such as owner, description, star count, and latest release tag, while highlighting those with APK releases or already tracked by the app. Users can search, sort by recent stars, alphabetical order, or star count, and filter to show only repositories without APKs. The picker also handles lifecycle events, rate limiting with a resume option, and navigation to repository details.

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

Introduce backend API client and proxy management infrastructure

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

Introduce comprehensive authentication UI and logic for GitHub Device Flow and Personal Access Tokens

The authentication screen now supports GitHub's Device Authorization Flow and Personal Access Token (PAT) sign-in. Users can initiate a device code flow, copy the code, and open GitHub for authorization, with the UI displaying dynamic polling status, rate-limit warnings, and error states. Additionally, a new PAT entry sheet allows users to input tokens, with validation for format, credentials, and scope, surfacing specific error messages. The flow includes deep-link handling for web OAuth handoffs and robust state management to prevent stranding users on blocked networks.

feature/auth/presentation/src/commonMain · high confidence

Introduce data layer for repository pages

This change adds the data and domain layers for the new repository pages feature, enabling in-app viewing of issues, pull requests, and security advisories. It defines domain models for issues, pull requests, and security advisories, along with Ktor-based DTOs and mappers to deserialize GitHub API responses. The implementation includes a repository interface and its Koin-di'ed implementation, providing methods to fetch issue lists, issue details with comments, pull request lists, and security overviews, while handling rate limits and network errors gracefully.

feature/repo-pages/data · high confidence

Introduce domain models and repository interface for developer profile feature

The \feature/dev-profile/domain\ module now defines the core data structures and access contracts for the new developer profile capability. This includes the \DeveloperRepository\ model containing fields for repository metadata (such as stars, forks, and release status), along with enums for filtering (\RepoFilterType\) and sorting (\RepoSortType\) repositories. A \DeveloperProfileRepository\ interface is provided to fetch developer profiles, their repositories, and contribution calendars, establishing the domain layer for this feature.

feature/dev-profile/domain · high confidence

Introduce domain repository interfaces for authentication flows

This change adds the core domain-layer contracts for authentication, defining the \AuthenticationRepository\ interface which exposes flows for access tokens and methods for GitHub device flow polling, Personal Access Token (PAT) sign-in, and web OAuth registration/handoff. It also introduces supporting types including the \AuthPath\ enum (distinguishing between Backend and Direct paths), \PollOutcome\ to track polling results and the path used, and \PatRejectedException\ to handle specific PAT rejection scenarios.

feature/auth/domain/src/commonMain · high confidence

Introduce domain-layer abstractions for diagnostics, platform detection, and installation metadata

The core/domain module now includes new interfaces and models that support diagnostic logging with credential redaction, platform-specific helpers (Android/Desktop), and detailed installation metadata (installer types, categories, and availability). This provides the structural foundation for features like session-only developer logs, OS/locale exposure, and refined app installation tracking.

core/domain · high confidence

Introduce external app import wizard with bulk-undo and search overrides

The presentation layer now includes a new external import workflow (ExternalImportRoot, ViewModel, and Action/State models) that guides users through scanning for and linking installed apps to repositories. Key capabilities include a multi-step wizard UI, bulk-undo support via pre-link snapshots, and the ability to override search queries for specific packages. The flow handles permission requests, displays progress and summary screens, and allows users to skip individual or remaining packages.

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

Introduce feed data layer with offline support

This change adds the data-layer implementation for the feed feature, introducing \FeedRepositoryImpl\ and its Koin DI module (\SharedModule.kt\). The repository now fetches feed data from the backend with caching, and specifically for page 1, it falls back to fetching a merged offline mirror of platform-specific JSON files if the network request fails, ensuring content availability without connectivity.

feature/feed/data · high confidence

Introduce in-app Issues and Security viewers

This change adds the presentation layer for viewing repository issues and pull requests directly within the app. It introduces dedicated screens for listing issues and pull requests with open/closed filtering and pagination, as well as a detailed view for individual issues that supports commenting and reaction toggling. The implementation includes new UI components for markdown rendering, label chips, and standard loading/error/empty states, all wired to view models that handle data fetching and user actions.

feature/repo-pages/presentation/src · high confidence

Introduce new DTOs for cached GitHub repository data

The home feature's data layer now uses a new set of serializable data classes (CachedGithubOwner, CachedGithubRepoSummary, CachedRepoResponse) to represent cached GitHub repository information. These DTOs include fields for repository metadata such as owner details, star/fork counts, language, topics, and platform availability, enabling the UI to display comprehensive repository summaries.

feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/dto · high confidence

Introduce new Feed feature with platform/category filtering and grid layout

The Feed screen now supports browsing repositories by platform (e.g., GitHub, GitLab) and category, with a dedicated platform picker and category chips. Users can toggle between list and grid layouts, mark repositories as seen or hidden, share links, and refresh or load more content. The view model manages state for loading, errors, and offline status, while the UI adapts to desktop and mobile layouts.

feature/feed/presentation/src · high confidence

Introduce presentation models for the Apps feature

This change introduces a new set of UI models in the Apps presentation layer to support advanced app management and grouping. Users will benefit from the ability to group apps that share a repository, select preferred APK variants, and manage pre-release update settings. The update experience is enhanced with granular state tracking (idle, checking, downloading, installing, success, error) and progress indicators for bulk updates. Additionally, the UI now supports sorting options (updates first, recently updated, name) and displays detailed status flags for filters, pinned variants, and pending installations.

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

Introduce search data layer with dependency injection and caching

The search feature now includes a dedicated data module that wires up the search repositories via Koin. SearchRepositoryImpl is configured to use a backend API client, cache manager, Forgejo client registry, and token store, enabling repository discovery and search capabilities. A SearchHistoryRepositoryImpl is also provided for tracking search history. Additionally, an LRU cache utility class has been added to support efficient data caching within the search data layer.

feature/search/data/src/commonMain/kotlin/zed/rainxch/search/data/di · high confidence

Introduce the 'Tweaks' settings feature and UI

A new 'Tweaks' settings screen has been added, consolidating app-level configuration into a single location. Users can now manage appearance (personality, accent, theme, font, layout, content width, refresh rate), connectivity (scoped proxy settings with testing, custom forges, mirror picker with latency measurement), installation preferences (installer type including Shizuku/Dhizuku/Root/Third-party, attribution), update behaviors (auto-check toggle, interval, pre-releases), privacy (hidden/skipped repositories, access tokens), and diagnostics (feedback form, cache management, crash logs). The feature includes platform-specific behaviors, such as a language change restart prompt on Desktop and battery-optimization card visibility on aggressive OEM devices.

feature/tweaks · high confidence

Introduce topic-based repository discovery and filtering on the Home screen

Users can now discover repositories by specific topics (such as Privacy, Media, Productivity, Networking, and Dev Tools) in addition to the existing Trending, Hot Release, and Most Popular categories. This capability is enabled by new domain models (\TopicCategory\, \HomeCategory\) and a unified \HomeRepository\ interface that supports filtering by \DiscoveryPlatform\ and searching via topic keywords, allowing the home feed to present curated, topic-relevant results.

feature/home/domain/src/commonMain · high confidence

Introduce web OAuth flow with PKCE and improved authentication error handling

The authentication data layer now supports a web-based OAuth flow using PKCE (Proof Key for Code Exchange) for secure browser-based sign-ins, implemented via new \PkceGenerator\ and \WebAuthApi\ components that handle registration and token handoff. Additionally, the \AuthenticationRepositoryImpl\ has been updated to include robust error handling for device flow polling, such as rate-limit backoff and network error recovery, and implements a fallback mechanism that switches from backend-proxied to direct GitHub API calls if the backend is unavailable.

feature/auth/data/src/commonMain · high confidence

Introduces Android-specific implementations for app launching, browsing, clipboard, and file sharing

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

Introduces AppsRepository implementation and Koin dependency injection

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

Introduces Desktop-specific dependency injection bindings

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

Introduces GitHub Device Flow authentication and PAT validation infrastructure

The auth data layer now supports the GitHub Device Flow for user sign-in, introducing a new \GitHubAuthApi\ that handles device code initiation, token polling with rate-limit awareness, and proxy configuration updates. This includes specific DTOs for device start and token responses, alongside a \PkceTriplet\ data class for cryptographic state management. Additionally, a new \PatValidation\ sealed interface standardizes Personal Access Token validation outcomes (Valid, Rejected, Unreachable), and the presentation layer adds \AuthDeepLinkEvent\ types to handle authentication handoffs and errors.

feature/auth/data · 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

Introduces domain models for APK validation, release caching, and repository statistics

The details domain layer now includes new data models to support richer repository information and safer installation workflows. Users will see updated repository details including download counts, license information, and standard stats (stars, forks, issues) via the new RepoStats model. The app also introduces structured results for APK validation (ApkValidationResult), fingerprint verification (FingerprintCheckResult), and general verification (VerificationResult), ensuring clearer feedback on installation integrity. Additionally, a CachedReleases model is added to store GitHub release lists locally, and parameter models (SaveInstalledAppParams, UpdateInstalledAppParams) are defined to capture detailed installation context, including pending install status and asset metadata.

feature/details/domain · high confidence

Introduces personality-driven UI components and adaptive layout infrastructure

This change adds a suite of new presentation components that adapt their appearance based on the active design personality (Classic or Manga). Users will see new implementations for navigation bars (KomiBottomBar), action bars (KomiActionBar), and top bars (KomiTopBar) that render distinct styles for each theme. The update also introduces an adaptive list-detail layout (AdaptiveListDetail) allowing resizable panes on wide screens, a new badge system (KomiBadge) with size and tone variants, and a scrollbar container for lazy lists and grids. Additionally, it includes a reusable image loading component (GitHubStoreImage) and a profile avatar specification.

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

Introduces robust download orchestration, install serialization, and app version info services

This change adds several new core services in the data layer to improve reliability and user experience. The new DefaultDownloadOrchestrator manages background downloads with concurrency limits, handles orphaned partial files, and supports re-fetching assets when URLs are gone. A new DefaultSystemInstallSerializer serializes installation requests to prevent race conditions, ensuring only one install proceeds at a time while handling timeouts and cancellations correctly. Additionally, a new BuildKonfigAppVersionInfo provider exposes the app's version code and name, and a LocalizationManager interface is introduced to support dynamic language switching.

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

Introduces robust dual-layer caching with periodic cleanup

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

JVM-specific implementations for platform utilities

The presentation layer now includes JVM-specific implementations for package visibility requests, reduced motion preferences, and SDK level detection. On the JVM target, package visibility is always granted, reduced motion is disabled, and the SDK level is reported as unknown, ensuring the import wizard functions correctly in desktop environments where these Android-specific permissions and APIs are not applicable.

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

New Dev Profile UI components and contribution calendar

The Dev Profile feature now includes a redesigned presentation layer with new components: a ContributionCalendarCard that visualizes activity via a Canvas-based grid with a color-coded legend, a ProfileInfoCard displaying user metrics and clickable bio mentions, a DeveloperRepoItem listing repository details with favorite toggles and metadata chips, and FilterSortControls for searching and filtering repositories. These components adopt the new personality-driven design system, utilizing core UI primitives like KomiSurface and KomiText, and replace previous implementations to provide a consistent, expressive interface for developer profile data.

feature/dev-profile/presentation/src/commonMain/kotlin/zed/rainxch/devprofile/presentation/components · high confidence

New Profile feature with Announcements and logout confirmation

The Profile screen now includes a dedicated Announcements section where users can view, expand, and acknowledge updates, with the ability to mute specific categories via a settings sheet. A confirmation dialog is now required before logging out, and the profile UI displays navigation entries for starred and favorite repositories, recently viewed items, and a 'What's new' entry.

feature/profile/presentation/src · high confidence

New apps library UI with advanced settings and import summaries

The apps screen now uses a new set of presentation components to display tracked apps and downloads. A new AdvancedAppSettingsBottomSheet lets users configure asset filters, fallback to older releases, and manage APK variant preferences. The main list uses LibraryRow and LibraryAppRow to show app status, tags (such as pre-release or ignored updates), and actions, while LibraryDownloadRow handles active downloads with pause, resume, and retry controls. AppGroupCard and AppsSectionHeader provide collapsible, accessible section headers for grouped apps. The AppsTopbar adds sorting, update checking, and import/export options, including a specific entry for Obtainium exports. An ImportSummarySheet displays the results of app imports, categorizing them into imported, skipped, not installed, non-GitHub, and failed buckets.

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

New attestation verification and installation management logic

The app now includes a new AttestationVerifierImpl that computes SHA-256 digests of APK files and checks them against repository attestations to verify integrity, and an InstallationManagerImpl that handles APK validation, signing fingerprint checks against existing installations, and the saving or updating of installed app records in the database.

feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/system · high confidence

New category list view with width-driven grid layout

The home screen now includes a dedicated Category List screen that displays repositories in a staggered grid, supporting Hot Releases, Trending, and Most Popular categories. The layout adapts to screen width using a width-driven grid specification, and users can toggle between a compact grid and a standard list view via a tweak setting. The screen supports infinite scrolling with automatic loading of more pages, pull-to-refresh functionality, and navigation to individual repository details upon tapping a card.

feature/home/presentation/src/commonMain/kotlin/zed/rainxch/home/presentation/categorylist · high confidence

New data layer and network infrastructure for downloads, caching, and rate limiting

The core data module now includes a comprehensive set of Room database entities (CacheEntry, ExternalLink, FavoriteRepo, HiddenRepo, InstalledApp, SearchHistory, SeenRepo, SigningFingerprint, StarredRepository, UpdateHistory) to support features like hiding seen repositories, search history, and detailed installed app tracking. A new download orchestration system (PartialDownload) enables resumable downloads with partial file reuse and metadata tracking. Network capabilities are enhanced with a MirrorRewriter for GitHub URL rewriting, a BackendRateLimitTracker and RateLimitInterceptor for proactive rate limit handling, and an UnauthorizedInterceptor for session expiration management. Additionally, an ObtainiumImportMapper allows users to import app configurations from the Obtainium format. Also in this area: Automatic per-host token injection for network requests; New data layer components for download detection, rate limiting, and announcements.

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

New data layer repositories for announcements, caching, external app imports, and user preferences

This change introduces a suite of new repository implementations in the core data layer to support recent feature additions. AnnouncementsCacheStoreImpl manages cached announcement payloads with a migration from legacy DataStore storage to KSafe. CacheRepositoryImpl provides functionality to observe cache size and clear cache files. ExternalImportRepositoryImpl and its supporting logic (ExternalLinkMerging, StarredRepoMatching) handle the scanning of installed apps, matching them to repositories, and managing pending link reviews. Additional repositories include FavouritesRepositoryImpl, HiddenReposRepositoryImpl, and SeenReposRepositoryImpl for managing user repository visibility and favorites; HostTokenRepositoryImpl for secure storage and validation of host-specific tokens; InstalledAppsRepositoryImpl for tracking installed apps and checking for updates; and TweaksRepositoryImpl for persisting user preferences like theme, personality, and installer settings, also featuring a migration from legacy storage.

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

New data mappers for announcements, external app matching, and repository discovery

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

New data models for announcements, what's new, and backend repository responses

The data layer introduces DTOs to support new content and backend-driven repository features. AnnouncementDto and AnnouncementsResponseDto enable version- and platform-targeted in-app announcements with localized text and acknowledgment requirements. WhatsNewEntryDto and WhatsNewSectionDto provide the structure for the 'What's New' release notes. BackendRepoResponse, BackendExploreResponse, BackendFeedResponse, and BackendSearchResponse (including passthroughAttempted) model repository discovery, feed, and search results from the backend, including license, download counts, and release recency. Additional models for GitHub device authentication, starred repositories, external match requests/responses, mirror lists, and signing fingerprint seeds support authentication, discovery, and security workflows.

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

New data models for import candidate UI and repository suggestions

The import flow now uses a dedicated set of UI models to represent import candidates and their associated repository suggestions. CandidateUi structures the core app metadata (package name, label, version, installer) alongside a list of RepoSuggestionUi items and a pre-selected suggestion. RepoSuggestionUi exposes source details (manifest, search, fingerprint, manual, or starred), confidence scores, star counts, and descriptions, while automatically determining a visual tone (Primary or Muted) based on confidence thresholds. ImportPhase defines the distinct stages of the import lifecycle, and PendingUndo captures the state required to reverse an import action, linking back to the candidate and any external decision snapshot.

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

New domain interfaces for attestation verification and installation management

The domain layer now exposes two new interfaces: \AttestationVerifier\, which defines the contract for verifying attestation status for a specific repository file, and \InstallationManager\, which handles APK validation, signing fingerprint checks, and the persistence of installed app records. These interfaces decouple the core logic for installation and validation from the UI layer, providing a structured API for system-level app details.

feature/details/domain/src/commonMain/kotlin/zed/rainxch/details/domain/system · high confidence

New domain models for GitHub repo info and import results

Added \GithubRepoInfo\ and \ImportResult\ domain models to support app linking, import/export, and pre-release features. \GithubRepoInfo\ captures repository metadata including owner details, description, language, HTML URL, and latest release tag. \ImportResult\ tracks the outcome of import operations, categorizing items as imported, skipped, failed, non-GitHub skipped, or not installed, while also recording the source format and providing previews for unknown formats.

feature/apps/domain · high confidence

New domain models for search filtering and sorting

The search domain layer now includes explicit models for filtering by programming language and sorting results. A new \ProgrammingLanguage\ enum allows users to filter repositories by specific languages (e.g., Kotlin, Java, Python) or view all, with a helper to map string inputs to these options. Sorting capabilities have been expanded with a \SortBy\ enum supporting options like MostStars, MostForks, BestMatch, RecentlyUpdated, and RecentlyReleased, which map to corresponding GitHub API parameters. Additionally, a \SortOrder\ enum enables users to specify whether results should be sorted in ascending or descending order.

feature/search/domain/src/commonMain/kotlin/zed/rainxch/domain/model · high confidence

New domain repositories for repository details and translations

The application introduces two new domain-layer interfaces: \DetailsRepository\ and \TranslationRepository\. \DetailsRepository\ centralizes access to repository metadata, including fetching repo summaries, refreshing data, retrieving release lists (with caching and bypass options), reading README content, gathering repository statistics, fetching user profiles, and verifying GitHub artifact attestations. \TranslationRepository\ provides a mechanism to translate text content into a target language and retrieve the device's current language code, supporting the new translation features for 'About' and 'What's New' sections.

feature/details/domain/src/commonMain/kotlin/zed/rainxch/details/domain/repository · high confidence

New external import wizard screens and components

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

New local database data access objects for app management and user preferences

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

New rate limit and session expiration dialogs

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

New search UI models for sorting and source selection

The search feature now exposes new presentation models that allow users to filter and sort results. Users can sort repositories by Most Stars, Most Forks, Best Match, Recently Updated, or Recently Released, with control over ascending or descending order. Additionally, the search source can be selected from GitHub, Codeberg, or a custom forge, and programming language filters include options like Kotlin, Java, and Python.

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

New search domain repository interfaces for history and discovery

The search domain layer now exposes two new repository interfaces: SearchHistoryRepository, which allows users to manage their recent search queries via flow-based retrieval and individual or bulk removal, and SearchRepository, which defines the contract for discovering repositories. The search capability now supports filtering by platform, programming language, and sort criteria (including direction), paginated results, and a specific 'explore from GitHub' function that returns an ExploreResult.

feature/search/domain/src/commonMain/kotlin/zed/rainxch/domain/repository · high confidence

New search filter and history UI components

The search interface now includes dedicated UI components for managing filters and history. Users can apply source, platform, language, and sort filters via a new SearchFiltersSheet, with specific bottom sheets for selecting languages (LanguageFilterBottomSheet) and sort options (SortByBottomSheet). Additionally, a SearchHistorySection displays recent searches, allowing users to click to re-run a query, remove individual items, or clear the entire history.

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

Platform-specific presentation utilities for Android and Desktop

This change introduces platform-specific implementations for core presentation utilities in the Android and Desktop (JVM) codebases. On Android, the app now supports selecting display refresh rates via the system DisplayManager, loads icon seed colors by resolving installed app icons or fetching images via Coil (ensuring software bitmaps for quantization), observes system timezone changes to update the UI, and enables pull-to-refresh gestures. On Desktop, display mode selection is hidden as there is no per-window mode, icon seeding relies solely on image URLs, timezone change observation is a no-op, and pull-to-refresh is disabled.

core/presentation/src/androidMain/kotlin/zed/rainxch/core/presentation/utils, core/presentation/src/jvmMain/kotlin/zed/rainxch/core/presentation/utils · high confidence

Redesigned Home screen with category tabs, platform filtering, and repository actions

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. Also in this area: 7 commits (2 fixes) modifying feature/auth.

feature/home/presentation · medium confidence · unverified

The search feature now includes utilities to map internal sort and language models to localized display labels, supporting new sorting options like 'Recently Updated' and 'Recently Released' alongside standard sorts. Additionally, a new utility detects and parses GitHub repository URLs from text input, enabling users to easily identify and interact with repository links within the search interface.

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

Search feature restructured with new filtering, sorting, and history capabilities

The search presentation layer has been rebuilt to support a richer set of search controls and user interactions. Users can now filter results by source (GitHub, Codeberg, or custom forges), platform, and programming language, and sort results by stars, forks, best match, recently updated, or recently released, with configurable ascending or descending order. A new search history feature allows users to view, select, and clear recent queries. The UI also introduces a 'seen' status indicator for repositories, the ability to hide seen repositories, and a grid layout toggle for search results. Additionally, the search screen now detects GitHub links from the clipboard and provides an 'Explore from GitHub' option. Also in this area: 5 commits (1 fix) modifying feature/search.

feature/search/presentation · medium confidence · unverified

Silent installation now supports Shizuku, Dhizuku, and Root backends

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

Support for app linking, export, and import with format detection

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

Wire home data layer dependencies via Koin

The home feature's data layer is now configured with a Koin module that provides the HomeRepository and CachedRepositoriesDataSource. This wiring injects the BackendApiClient, cache manager, and platform-specific dependencies into the repository implementation, enabling the home screen to fetch and cache repository data.

feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/di · high confidence

Architecture

Centralized Koin dependency injection setup

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

Establishes core data dependency injection and repository wiring

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

Introduce convention plugins for modularized Android and KMP builds

The build logic now uses a set of new convention plugins to standardize configuration across the project. Android application modules are configured via AndroidApplicationConventionPlugin (setting namespace, SDK versions, and enabling ProGuard/resource shrinking for release) and AndroidApplicationComposeConventionPlugin (applying the Compose compiler). Android library modules use AndroidLibraryConventionPlugin. Multiplatform modules are handled by KmpLibraryConventionPlugin (applying Kotlin Multiplatform, Android KMP library, and serialization) and CmpLibraryConventionPlugin (applying JetBrains Compose and stability analysis). Feature modules use CmpFeatureConventionPlugin to wire up common dependencies like Koin and JetBrains Compose components. Additional plugins standardize BuildKonfig generation (exposing GitHub client ID and version info), Room database schema management, and code quality checks via Detekt and Kover.

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

Wire details data-layer dependencies via Koin

The app now uses a Koin module to inject the implementations for the details repository, translation repository, attestation verifier, and installation manager. This ensures that the details feature correctly accesses backend data, handles translations, verifies app signatures, and manages installations through the configured dependency graph.

feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/di · high confidence

Behavioural changes

1 commit (0 fixes) modifying composeApp/src/jvmMain/resources

A change to existing behaviour in composeApp/src/jvmMain/resources — 1 commit, 3 files: “Relocate application icons and update build configuration”.

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

12 commits (0 fixes) modifying feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation/components

A change to existing behaviour in feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation/components — 12 commits, 1 file: “build: update dependencies and migrate preview imports”; “refactor(resources): Consolidate resources into core module”; “add shape to favorite toggle button using MaterialShapes.Cookie6Sided”; and 8 more (refs \#731, \#666, \#1146, \#792, \#1080).

feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation/components · medium confidence · unverified

19 commits (1 fix) modifying feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data\_source

A change to existing behaviour in feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data\_source — 19 commits (1 fix), 2 files: “Improve backend result validation and search fallback logic”; “Integrate BackendApiClient for optimized repository discovery and search”; “refactor: improve repository platform detection and data merging”; and 16 more (refs \#997, \#731, \#666, \#792, \#790).

_feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data\source · medium confidence · unverified

2 commits (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 2 commits, 69 files: “feat(reviews): an expressive look for ratings and reviews, plus review fixes (\#1224)”; “feat(reviews): ratings and reviews for apps (\#1222)” (refs \#1224, \#1222). Also in this area: Added Compose stability analysis report for presentation components.

core/presentation/stability, feature/reviews · medium confidence · unverified

20 commits (0 fixes) modifying feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/repository

A change to existing behaviour in feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/repository — 20 commits, 1 file: “feat(core): Implement robust caching system with Room and Memory Cache”; “feat: enhance repository discovery and platform-specific filtering”; “refactor(home): Revise home categories and data fetching logic”; and 16 more (refs \#476, \#731, \#666, \#792, \#790, …).

feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/repository · medium confidence · unverified

24 commits (4 fixes) modifying feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation

A change to existing behaviour in feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation — 24 commits (4 fixs), 7 files: “feat: add arrow key navigation for scrollable lists and grids”; “build: update dependencies and migrate preview imports”; “refactor(resources): Consolidate resources into core module”; and 20 more (refs \#628, \#1164, \#922, \#1041, \#731, …).

feature/starred/presentation/src/commonMain/kotlin/zed/rainxch/starred/presentation · medium confidence · unverified

25 commits (3 fixes) modifying core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db/entities

A change to existing behaviour in core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db/entities — 25 commits (3 fixs), 10 files: “feat: enhance asset variant picking and pinning”; “feat: implement APK signing fingerprint verification and improve Shizuku integration”; “feat: implement per-app pre-release update settings”; and 21 more (refs \#934, \#380, \#542, \#1149, \#998, …).

core/data/src/commonMain/kotlin/zed/rainxch/core/data/local/db/entities · medium confidence · unverified

3 commits (0 fixes) modifying feature/favourites, feature/profile, feature/recently-viewed

A change to existing behaviour in feature/favourites, feature/profile, feature/recently-viewed — 3 commits, 27 files: “docs: AGENTS.md for every coding agent, docs/agents topic files, /verify and a CONTRIBUTING refresh (\#1076)”; “ci: PR checks for build, tests, coverage, Spotless, detekt, Lint and Compose stability (\#1056)”; “style: one-time Spotless format of every Kotlin file (\#1080)” (refs \#1076, \#1056, \#1080). Also in this area: Added import stars event definitions; Introduce Favourites feature with search, sorting, and import capabilities.

feature/favourites/presentation · medium confidence · unverified

5 commits (0 fixes) modifying feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/translation

A change to existing behaviour in feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/translation — 5 commits, 6 files: “Introduce a configurable translation provider system, adding support for Youdao as an alternative to Google Translate”; “tweak: implement draft states and improve Google translation reliability”; “Refresh the design of GHS (\#666)”; and 2 more (refs \#666, \#649, \#1080).

feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/translation · medium confidence · unverified

6 commits (1 fix) modifying feature/feed

A change to existing behaviour in feature/feed — 6 commits (1 fix), 13 files: “fix(feed): leave iOS out of the platform picker (\#1084)”; “build(detekt): allow 140-column lines, like ktlint (\#1082)”; “docs: correct the agent docs against the code (\#1093)”; and 3 more (refs \#1084, \#1082, \#1093, \#1076, \#1056, …). Also in this area: Unified discovery feed and layout control moved to Tweaks; Initial feed domain model and presentation event definitions.

feature/feed/presentation · medium confidence · unverified

7 commits (2 fixes) modifying feature/auth

A change to existing behaviour in feature/auth — 7 commits (2 fixs), 45 files: “build(detekt): allow 140-column lines, like ktlint (\#1082)”; “docs: correct the agent docs against the code (\#1093)”; “fix(auth): send sign-in requests through the in-app proxy (\#1089)”; and 4 more (refs \#1082, \#1093, \#1089, \#1076, \#1056, …). Also in this area: Introduce typed domain models for authentication flows; Introduce PKCE-based Web OAuth and resilient GitHub authentication flows.

feature/auth/domain · medium confidence · unverified

Added Android app build configuration and optimization rules

The androidApp module now includes essential build-time configuration files: a ProGuard/R8 rules file to preserve critical classes for serialization, navigation, and the Shizuku/Dhizuku installer services; a detekt baseline to suppress known code-smell warnings; and a lint baseline to ignore missing classes and translation issues. These changes ensure the app builds correctly with code shrinking enabled and static analysis tools are configured to the current codebase state.

androidApp · high confidence

Android-specific utilities for system preferences and SDK detection

This update introduces Android-specific implementations for three utility providers used in the import flow. The PackageVisibilityRequester now checks if the app has access to installed packages by verifying if the count exceeds a threshold of 30, returning false for request or settings actions. The ReducedMotionProvider reads the system's animator duration scale to determine if reduced motion is enabled. Additionally, the SdkLevelProvider exposes the current Android SDK version for conditional logic.

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

Announcements cache moved to a dedicated DataStore instance

The application now stores the announcements cache in its own separate DataStore file (github\_store\_announcements.preferences\_pb) instead of sharing the general preferences store. This separation isolates announcement data, which can improve performance and maintainability by preventing the main preferences file from growing with announcement-related entries.

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

Announcements cache moved to dedicated persistent storage with migration support

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

Announcements data is now persisted in a dedicated DataStore instance

The application now stores announcements cache in its own separate DataStore file, distinct from the general application preferences. This separation ensures that announcement data is managed independently, potentially improving performance and data integrity by isolating this specific cache from other user settings or app state.

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

Apps screen now uses a staggered masonry layout

The app library grid has been changed from a standard list to a staggered masonry layout, allowing items of varying heights to fit together more compactly. This change is reflected in the new stability analysis file which documents the composables for the Apps screen, including the new \KeepAtTopWhenSectionsChange\ helper for the staggered grid state.

feature/apps/presentation/stability · high confidence

Centralized app shell with unified theme, navigation, and dialog management

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

Database initialization now includes destructive fallback on downgrade

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

Database schema updated to version 18 with new entities and DAOs

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

Generated Compose stability analysis for the Details feature

The Details feature's presentation layer now includes an automatically generated stability report (presentation.stability) produced by the Compose Stability Analyzer. This file documents the stability characteristics of key composables, highlighting that while navigation callbacks and state objects are generally stable, several domain model parameters (such as ApkInspection, GithubRepoSummary, and InstalledApp) are currently marked as unstable or require runtime checks, and the DetailsViewModel remains unstable. This provides visibility into potential recomposition performance issues within the Details screen and its sub-components like the AppHeader and AboutScreen. Also in this area: 2 commits (0 fixes) modifying (repo-wide).

feature/details/presentation/stability · medium confidence · unverified

Improved downgrade detection logic in VersionHelper

The VersionHelper utility now uses semantic version comparison for detecting downgrades when both versions follow a recognized scheme, falling back to release-list ordering only when schemes are unknown or versions are equal. This change ensures that users are accurately notified of potential downgrades based on version semantics rather than arbitrary list positions, improving the reliability of installation verification.

feature/details/domain/src/commonMain/kotlin/zed/rainxch/details/domain/util · high confidence

Improved download reliability and notification controls

Downloads now handle missing asset URLs by automatically refetching the latest release information to recover the download source. The download engine also implements a mirror-first strategy with direct fallback to prevent race conditions and corruption, while notification actions are now context-aware, offering pause/resume/delete options based on the current download stage.

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

Installer AIDL interfaces moved to core:data-aidl module

The AIDL interface definitions for the installer services (IDhizukuInstallerService and IShizukuInstallerService) have been relocated into the :core:data-aidl module. This change organizes the inter-process communication contracts for package installation and uninstallation operations, making them available as a shared core dependency rather than being defined in their previous location.

core/data-aidl · high confidence

Introduce UI models and mappers for the apps feature

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

Introduce convention plugins for Android, Kotlin Multiplatform, and Compose configuration

This change introduces a new set of convention plugins in the build-logic module to standardize project configuration. It adds dedicated plugins for configuring Android Compose dependencies and features, setting up Kotlin Android compilation targets (JVM 17, desugaring, lint baselines), and establishing Kotlin Multiplatform targets (Android and JVM) with specific compiler arguments. Additionally, it includes utilities for path-based package naming and integrates the Compose Stability Analyzer to ignore non-regressive changes, streamlining the build setup for new modules.

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

Introduction of Kermit-based logging implementation

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

Komi Store Homebrew cask renamed and updated to v1.9.2

The Homebrew cask for the application has been renamed from 'github-store' to 'komi-store' to reflect the project's rebranding, requiring users to update their installation commands (e.g., \brew install --cask komi-store\). The cask has also been updated to version 1.9.2 with new SHA256 checksums for both ARM64 and Intel architectures, and the uninstall/zap paths have been adjusted to match the new application name and bundle identifiers.

dist · high confidence

Migrate GitHub device token storage to KSafe with automatic legacy migration

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

Mirror selection now persists securely and falls back to bundled mirrors

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

New data mappers for GitHub user and repository profiles

The dev-profile data layer now includes dedicated mapper functions to convert network and DTO models into domain entities. Specifically, \GitHubUserToDomain\ and \UserProfileNetworkToDomain\ map GitHub user data (including login, avatar, bio, and social links) to the \DeveloperProfile\ domain model, while \GitHubRepoToDomain\ and \GithubRepoNetworkModelToGitHubRepoResponse\ handle the conversion of repository details (such as stars, forks, and release status) to the \DeveloperRepository\ domain model. This ensures consistent transformation of backend responses into the application's internal domain structures.

feature/dev-profile/data/src/commonMain/kotlin/zed/rainxch/devprofile/data/mappers · high confidence

Persistent database storage and migration support for desktop

The desktop application now initializes the local Room database using persistent file paths instead of temporary storage, ensuring data survives restarts. The initialization logic includes a migration step to move existing database files from temporary locations to the proper app data directory. Additionally, the database builder is configured with specific migrations and a fallback strategy for downgrades that drops all tables rather than corrupting the database.

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

Persistent desktop storage paths and legacy data migration

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

Redesigned in-app What's New dialog with localized JSON content

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

Redesigned navigation with adaptive layouts and new screens

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

Search feature restructured with new UI actions, state model, and visibility filters

The search presentation layer has been refactored to use a new sealed interface for user actions (SearchAction), a dedicated state model (SearchState), and an updated ViewModel. This change introduces support for filtering results by 'seen' and 'hidden' repositories, automatic GitHub link detection from the clipboard, search history management, and grid/list layout toggling. The UI now handles platform selection, language filtering, and sort options through explicit action events, improving state management and user control over search results.

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

Stubbed external app scanner for JVM desktop builds

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

Fixes

Fix keyboard resizing behavior for tab cards on Android

The tab card component now correctly handles keyboard visibility on Android by resizing the window when tabs slide, ensuring the UI adjusts properly instead of being obscured. This change introduces platform-specific implementations for the \ResizeWindowForKeyboard\ function: the Android version manages soft input mode to force a resize during tab transitions, while the JVM version provides a no-op stub.

core/presentation/src/androidMain/kotlin/zed/rainxch/core/presentation/components/bars, core/presentation/src/jvmMain/kotlin/zed/rainxch/core/presentation/components/bars · high confidence

Test coverage

Added Compose Stability Analyzer reports for presentation modules; Added asset-matching replay corpus collection tool; Added database migration tests; Added instrumented UI tests for Android 17 (API 37) compatibility; Added static analysis tests for design tokens, documentation, and architecture; Added tests for AuthErrorMapper; Added tests for CacheManager disk-miss and memory-only behaviors; Added tests for HostTokenInterceptor; Added tests for UserProfileNetworkToDomain mapper; Added tests for auth proxy routing and error mapping; Added tests for auto-translate state mapping and language selection logic; Added tests for download mirror logic and version line resolution; Added tests for download notification actions, partial download logic, and progress throttling; Added tests for download orchestrator resilience and lifecycle; Added tests for grid layout calculations and error message handling; Added tests for markdown preprocessing of HTML tables and code blocks; Added tests for mirror selection and probing logic; Added tests for parked bytes matching logic; Added tests for starred repository DTO parsing; Added tests for update-check window, release binding, and parked-file cleanup; Added tests for version downgrade detection logic.

Dependencies

Gradle wrapper updated to version 9.8.1

The Gradle wrapper configuration has been updated to use Gradle 9.8.1. This ensures that builds will consistently use this specific version of the Gradle build tool, providing a stable and reproducible build environment for the project.

gradle · high confidence

Project modularized with convention plugins and version catalog

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

Housekeeping

Add lint and detekt baselines for core/presentation; Documentation of Home feature architecture and behavior.

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

How this codebase got here

Score

  • CAI 68 → 68 (+0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 81 → 81 (+0.0)
  • Architecture 85 → 85 (+0.3)
  • Maturity 63 → 64 (+0.3)
  • Readiness 69 → 69 (+0.0)
  • Security 70 → 70 (+0.0)
  • Domain Modelling 74 → 74 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (139)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Documentation: no project overview (README.md)
  • Duplicated block (10 lines × 2) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/network/GitHubAuthApi.kt)
  • Duplicated block (10 lines × 2) (feature/repo-pages/data/src/commonMain/kotlin/zed/rainxch/repopages/data/repository/RepoPagesRepositoryImpl.kt)
  • Duplicated block (10–11 lines × 2) (core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt)
  • Duplicated block (10–11 lines × 3) (feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt)
  • Duplicated block (10–12 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/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.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) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/inputs/ClassicTextField.kt)
  • Duplicated block (11 lines × 2) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/inputs/KomiCheckbox.kt)
  • Duplicated block (11 lines × 2) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt)
  • Duplicated block (11 lines × 2) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/components/SmartInstallButton.kt)
  • Duplicated block (11 lines × 2) (feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data_source/impl/CachedRepositoriesDataSourceImpl.kt)
  • Duplicated block (11 lines × 2) (feature/repo-pages/presentation/src/commonMain/kotlin/zed/rainxch/repopages/presentation/issues/IssuesRoot.kt)
  • Duplicated block (11 lines × 3) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/about/DetailsAboutViewModel.kt)
  • Duplicated block (11 lines × 5) (core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/BackendApiClient.kt)
  • Duplicated block (11–12 lines × 2) (feature/details/data/src/commonMain/kotlin/zed/rainxch/details/data/repository/DetailsRepositoryImpl.kt)
  • …and 119 more

New (456)

  • Dependency hygiene PARTLY measured — Gradle build resolved part of the dependency graph, currency reported but not scored
  • Duplicated block (10 lines × 2) (feature/auth/data/src/commonMain/kotlin/zed/rainxch/auth/data/network/GitHubAuthApi.kt)
  • Duplicated block (10 lines × 2) (feature/repo-pages/data/src/commonMain/kotlin/zed/rainxch/repopages/data/repository/RepoPagesRepositoryImpl.kt)
  • Duplicated block (10 lines × 2) (feature/reviews/presentation/src/commonMain/kotlin/zed/rainxch/reviews/presentation/ReviewsRoot.kt)
  • Duplicated block (10–11 lines × 2) (core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.kt)
  • Duplicated block (10–11 lines × 3) (feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt)
  • Duplicated block (10–12 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/androidMain/kotlin/zed/rainxch/core/data/services/AndroidDownloader.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/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) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/inputs/ClassicTextField.kt)
  • Duplicated block (11 lines × 2) (core/presentation/src/commonMain/kotlin/zed/rainxch/core/presentation/components/inputs/KomiCheckbox.kt)
  • Duplicated block (11 lines × 2) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt)
  • Duplicated block (11 lines × 2) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/components/SmartInstallButton.kt)
  • Duplicated block (11 lines × 2) (feature/home/data/src/commonMain/kotlin/zed/rainxch/home/data/data_source/impl/CachedRepositoriesDataSourceImpl.kt)
  • Duplicated block (11 lines × 2) (feature/repo-pages/presentation/src/commonMain/kotlin/zed/rainxch/repopages/presentation/issues/IssuesRoot.kt)
  • Duplicated block (11 lines × 3) (feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/about/DetailsAboutViewModel.kt)
  • Duplicated block (11 lines × 5) (core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/BackendApiClient.kt)
  • …and 436 more

Changes since last survey

  • 2 commits — 2 feature/other, 0 fixes

By area

  • core/presentation — 2 commits

Notable commits

  • change: feat(reviews): an expressive look for ratings and reviews, plus review fixes (#1224)
  • change: feat(reviews): ratings and reviews for apps (#1222)

Architecture

  • Containers 0 added · 0 removed · contexts 24 added · 23 removed · edges 46 added · 44 removed

Added bounded contexts (24)

  • core/data
  • core/domain
  • core/presentation
  • feature/apps/domain
  • feature/apps/presentation
  • feature/auth/data
  • feature/auth/domain
  • feature/auth/presentation
  • feature/details/data
  • feature/details/domain
  • feature/details/presentation
  • feature/dev-profile/data
  • feature/dev-profile/domain
  • feature/favourites/presentation
  • feature/feed/domain
  • feature/feed/presentation
  • feature/home/data
  • feature/home/presentation
  • feature/profile/presentation
  • feature/repo-pages/domain
  • …and 4 more

Removed bounded contexts (23)

  • core/data
  • core/domain
  • core/presentation
  • feature/apps/domain
  • feature/apps/presentation
  • feature/auth/data
  • feature/auth/domain
  • feature/auth/presentation
  • feature/details/data
  • feature/details/domain
  • feature/details/presentation
  • feature/dev-profile/data
  • feature/dev-profile/domain
  • feature/favourites/presentation
  • feature/feed/domain
  • feature/feed/presentation
  • feature/home/data
  • feature/home/presentation
  • feature/profile/presentation
  • feature/repo-pages/domain
  • …and 3 more

Added dependency edges (46)

  • core/data → core/domain (coupling)
  • core/presentation → core/domain (coupling)
  • feature/apps/domain → core/domain (coupling)
  • feature/apps/presentation → core/domain (coupling)
  • feature/apps/presentation → core/presentation
  • feature/apps/presentation → feature/apps/domain (coupling)
  • feature/auth/data → core/data (coupling)
  • feature/auth/data → core/domain (coupling)
  • feature/auth/data → feature/auth/domain (coupling)
  • feature/auth/domain → core/domain (coupling)
  • feature/auth/presentation → core/domain
  • feature/auth/presentation → feature/auth/domain
  • feature/details/data → core/data
  • feature/details/data → core/domain (coupling)
  • feature/details/data → feature/details/domain (coupling)
  • feature/details/domain → core/domain (coupling)
  • feature/details/presentation → core/domain (coupling)
  • feature/details/presentation → core/presentation (coupling)
  • feature/details/presentation → feature/details/domain (coupling)
  • feature/dev-profile/data → core/data
  • …and 26 more

Removed dependency edges (was a dependency, now gone) (44)

  • androidApp → core/data
  • androidApp → core/domain
  • androidApp → core/presentation
  • composeApp → core/data
  • composeApp → core/domain (coupling)
  • composeApp → core/presentation (coupling)
  • core/data → core/domain (coupling)
  • core/presentation → core/domain (coupling)
  • feature/apps/domain → core/domain (coupling)
  • feature/apps/presentation → core/domain (coupling)
  • feature/apps/presentation → core/presentation
  • feature/apps/presentation → feature/apps/domain (coupling)
  • feature/auth/data → core/data (coupling)
  • feature/auth/data → core/domain (coupling)
  • feature/auth/data → feature/auth/domain (coupling)
  • feature/auth/domain → core/domain (coupling)
  • feature/auth/presentation → core/domain
  • feature/auth/presentation → feature/auth/domain
  • feature/details/data → core/data
  • feature/details/data → core/domain (coupling)
  • …and 24 more

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 19eb74474f5f45a63cca45fc1dc9b8f7314687f0 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.63+preprod-4a8cc97a9484.