azikar24/WormaCeptor

WormaCeptor is an Android debugging and monitoring toolkit that provides real-time insights into application performance, network traffic, and system state. It enables developers to intercept and inspect HTTP/WebSocket requests, monitor CPU, memory, and FPS metrics, and detect issues like memory leaks and thread violations. The system also offers utilities for simulating network conditions, managing secure storage, and browsing local databases and file systems.

The app now supports receiving push notifications via Firebase Cloud Messaging. A new WormaCeptorMessagingService handles incoming FCM messages by displaying system notifications that link back to the main activity, ensuring users are alerted to new content or updates directly from the device.

app/src/main/java/com/azikar24/wormaceptorapp/firebase · high confidence

The app now includes the \google-services.json\ file for Firebase integration, along with ProGuard rules to preserve Firebase Messaging classes required for push notifications. Additionally, new Compose vector drawables for the GitHub icon and the WormaCeptor logo have been added to the UI assets.

app · high confidence

The application now supports parsing PDF files. This change introduces a new \PdfParser\ component that detects PDF content via MIME type or magic bytes and extracts metadata such as page count, file size, version, title, author, and creation date using Android's \PdfRenderer\. It also handles edge cases like password-protected documents and invalid files, providing clear error messages to the user.

infra/parser/pdf · high confidence

Users can now parse and view Protobuf and gRPC binary payloads without requiring a schema file. The new \ProtobufBodyParser\ component detects \application/protobuf\, \application/x-protobuf\, \application/grpc\, and \application/grpc+proto\ content types, then decodes the wire format to display field numbers, wire types, and values (including varints, 64-bit, 32-bit, and length-delimited strings/binary). This enables inspection of raw Protobuf data directly in the application.

infra/parser/protobuf · high confidence

A new Secure Storage test screen has been added to the app, allowing users to inspect and manage encrypted preferences and Android KeyStore entries. The screen displays a list of encrypted preferences with masked values and a list of KeyStore aliases with algorithm details. Users can add new encrypted key-value pairs via a dialog, generate test data for both encrypted preferences and KeyStore entries, and toggle the visibility of sensitive values. The implementation uses the app's design system tokens and components, including WormaCeptorAlertDialog, WormaCeptorTextField, WormaCeptorCard, and WormaCeptorIconButton.

app/src/main/java/com/azikar24/wormaceptorapp/screens/securestorage · high confidence

The WebSocket feature now includes new UI components to enhance message inspection: DirectionFilterChips allow users to filter messages by sent or received direction with visual counts; MessageList displays incoming messages in an outlined card format with expandable payloads, direction indicators, type badges, and formatted timestamps; and StatsBar provides a summary of total versus filtered message counts. These components collectively improve the user's ability to navigate and analyze WebSocket traffic within the app.

features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket/ui/components · high confidence

The device info feature now includes a dedicated navigation route that integrates with the app's navigation graph. This change introduces an MVI-based architecture for the device info screen, handling view effects such as copying text to the clipboard and sharing content via system intents. Users can now access device information through a standardized navigation path, with UI interactions like clipboard copying and sharing triggering appropriate system responses.

features/deviceinfo/src/main/java/com/azikar24/wormaceptor/feature/deviceinfo/navigation · high confidence

Introduces a new foreground service that displays a draggable floating button on the screen, allowing users to quickly access the network inspector. The button uses the new design system tokens for sizing, colors, and animations, and persists its position across app restarts. It includes a shake-to-trigger gesture detection mechanism and provides a notification channel for the service status.

platform/android · high confidence

A new file defining navigation route constants for the test tools section of the application has been added. This introduces specific route identifiers for Home, Location, WebView, and Secure Storage, providing a centralized source for these navigation paths within the app's navigation layer.

app/src/main/java/com/azikar24/wormaceptorapp/navigation · high confidence

A new no-op implementation of the ServiceProvider interface has been added to the api/impl/no-op module. This implementation provides empty or null-returning stubs for all service methods (such as init, startTransaction, completeTransaction, and transaction retrieval), allowing the application to function without active monitoring or transaction tracking when this specific implementation is selected.

api/impl/no-op · high confidence

The viewer now supports navigation via deep links using the 'wormaceptor://' scheme. Users can open specific tabs (Transactions, Crashes, Tools) or directly launch individual diagnostic tools (such as Memory Monitor, FPS Monitor, CPU Monitor, Preferences, Database, File Browser, and many others) by using URIs like 'wormaceptor://tools/memory'. This enables external apps or shortcuts to directly open the viewer and navigate to specific debugging features.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/navigation · high confidence

The file browser now includes new utility functions to enhance the visual presentation of files. FileAppearance.kt introduces logic to automatically assign specific icons and color tints to files based on their type (directories, images, text, databases, or others) using the current theme scheme. Additionally, FileViewerUtils.kt provides syntax highlighting for JSON and XML content within the viewer, distinguishing keys, strings, numbers, and special tags with appropriate styling to improve readability.

features/filebrowser/src/main/java/com/azikar24/wormaceptor/feature/filebrowser/ui/util · high confidence

The project now includes a new code quality infrastructure that enforces coding standards and commit message formats. A pre-commit hook automatically runs Spotless for code formatting and Detekt for static analysis on staged Kotlin files, blocking commits that fail these checks. Additionally, a commit-msg hook enforces the Conventional Commits format for all commit messages. Detekt rules are configured to treat warnings as errors (with specific thresholds for complexity and naming), and a baseline file suppresses known existing issues in XmlHighlighter to allow the new strict rules to pass initially.

config · high confidence

The file browser feature now includes a new data layer that handles file system operations. This introduces a \FileSystemDataSource\ class responsible for low-level interactions with the Android file system, including listing directories, reading file contents (supporting PDF, images, JSON, XML, and text formats), retrieving file metadata, and deleting files. A corresponding \FileSystemRepositoryImpl\ wraps these operations in coroutines using \Dispatchers.IO\ to ensure they run off the main thread, providing the domain layer with a clean interface for file management.

features/filebrowser/src/main/java/com/azikar24/wormaceptor/feature/filebrowser/data · high confidence

Adds a new Android Studio plugin that integrates WormaCeptor directly into the IDE. The plugin registers a project service to communicate with an Android device via ADB, enabling the retrieval and clearing of captured network transactions. It provides a bottom tool window for browsing transaction summaries and viewing full request/response details, along with a status bar widget to monitor capture activity. Users can access these features via a new Tools menu group or a Ctrl+Shift+W keyboard shortcut.

plugins/android-studio · high confidence

The Database feature now includes a complete set of user-facing screens: DatabaseListScreen for browsing available databases with search and refresh actions, TableListScreen for viewing tables within a selected database, TableDataScreen for paginated table content and schema inspection, and QueryScreen for executing SQL queries with history support. These screens are built using the shared WormaCeptor design system (WormaCeptorTopBar, WormaCeptorSearchBar, WormaCeptorLoadableContent, etc.), ensuring consistent styling and behavior across the database module.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database/ui · high confidence

The Dependencies Inspector screen is now available, allowing users to view detected library dependencies. The interface includes a summary section, category and version filters, and a search bar that expands dynamically. Users can tap on a dependency to open a bottom sheet with detailed information, and the layout supports IME padding for text input fields.

features/dependenciesinspector/src/main/java/com/azikar24/wormaceptor/feature/dependenciesinspector/ui · high confidence

The viewer now supports a Favorites system that lets users pin up to 10 key tools (defaulting to Console Logs, Shared Preferences, and Memory Monitor) via a new FavoritesRepository backed by SharedPreferences. Crash reporting has been significantly enhanced with a new CrashListScreen featuring skeleton loading, empty states, and pull-to-refresh, alongside a redesigned CrashDetailScreen that includes swipe navigation between crashes with directional slide animations, haptic feedback, and improved stack trace parsing via CrashUtils to highlight app code and extract file/line locations.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/ui · high confidence

The File Browser feature is now available, allowing users to navigate the file system via a breadcrumb bar and sort or search entries. Users can view detailed file information (name, size, permissions) and open files directly within the app. Supported viewing modes include plain text, JSON (with syntax highlighting and validity checks), XML, binary (hex dump), images, and PDFs. The interface uses the app's design tokens and shared UI components for a consistent look and feel.

features/filebrowser/src/main/java/com/azikar24/wormaceptor/feature/filebrowser/ui · high confidence

The Logs feature now includes a dedicated UI screen that allows users to start and stop log capture, clear existing logs, and search through entries using a dedicated search bar. The interface provides level-based filtering via chips, displays real-time statistics (total and filtered counts), and supports auto-scrolling to the latest log entries. The layout integrates with the app's design system, using shared components for the top bar, search input, and floating action buttons, ensuring a consistent look and feel across the application.

features/logs/src/main/java/com/azikar24/wormaceptor/feature/logs/ui · high confidence

The Mock Rules feature is now available, allowing users to create, edit, and manage mock API rules. The implementation adopts a Model-View-Intent (MVI) architecture with a dedicated ViewModel and navigation graph. Users can toggle mocking globally or per-rule, delete individual or all rules, and configure detailed rule properties including HTTP method, URL pattern matching (exact, prefix, regex), response status codes, content types, response bodies, and configurable delays (none, fixed, or range). The UI utilizes the app's design system components for a consistent experience.

features/mockrules/src/main/java/com/azikar24/wormaceptor/feature/mockrules · high confidence

The Push Token feature now includes a dedicated ViewModel that manages the screen's state and user interactions. Users can fetch, refresh, delete, and copy push tokens, as well as clear token history and dismiss errors. The ViewModel exposes a one-time effect to copy the token to the system clipboard and maintains a view state that tracks the current token, a history of up to 20 entries, loading status, and any errors.

features/pushtoken/src/main/java/com/azikar24/wormaceptor/feature/pushtoken/vm · high confidence

The Secure Storage screen is now available, allowing users to view, search, and filter their stored secure entries. The interface uses the app's shared design system, including the WormaCeptorTopBar for navigation, a dynamic search bar, and filter chips for storage types. It displays a summary of accessible storage (Keystore and Encrypted Preferences) and lists entries in a scrollable view, with a bottom sheet for detailed entry information. The layout supports edge-to-edge display and handles IME padding for text input fields.

features/securestorage/src/main/java/com/azikar24/wormaceptor/feature/securestorage/ui · high confidence

A new user interface has been added for monitoring and managing thread violations. The screen displays a summary of violation statistics, allows filtering by violation type, and lists detected violations in a scrollable view. Users can start or stop monitoring via a play/pause button, clear all violations, and view detailed information about specific violations in a bottom sheet. The UI integrates with the app's shared design system, including the top bar, monitoring indicator, and state management components.

features/threadviolation/src/main/java/com/azikar24/wormaceptor/feature/threadviolation/ui · high confidence

A new WebView Monitor screen has been added, allowing users to view a list of intercepted web requests and inspect their details. The feature displays request statistics (total, successful, failed, pending) and provides a detailed view for individual requests, including status, URL, method, headers, response information, and error messages. The UI utilizes the app's shared design system tokens and components for consistent styling.

features/webviewmonitor/src/main/java/com/azikar24/wormaceptor/feature/webviewmonitor/ui · high confidence

This change introduces the public API surface for the WormaCeptor monitoring tool, defining the core interfaces and classes that enable integration. It exposes the \WormaCeptorApi\ singleton for initializing the library, managing feature flags (such as CPU, memory, and network monitors), and controlling the floating button and performance overlay visibility. The API also defines \WormaCeptorInterceptor\ for intercepting and recording HTTP traffic with configurable redaction and retention policies, \WormaCeptorWebSocket\ for tracking WebSocket connections, and \WormaCeptorWebView\ for monitoring WebView clients. Additionally, it provides the \ServiceProvider\ interface for transaction management and the \Feature\ enum to enumerate supported monitoring capabilities.

api/client/api · high confidence

The \api/client/src/main\ module now provides the public API surface for the WormaCeptor debugging toolkit, including a new Ktor HTTP client plugin alongside the existing OkHttp interceptor for network traffic capture. This release adds a \RedactionConfig\ system allowing developers to mask sensitive headers and JSON/XML body values before storage, and introduces a \Feature\ enum for selectively enabling or disabling debugging capabilities like memory monitoring and leak detection. The module also registers the \WormaCeptorContentProvider\ for IDE plugin communication via ADB and exposes APIs for monitoring WebSockets, WebViews, and Jetpack Compose recompositions.

api/client/src/main · high confidence

A new common presentation module has been added to standardize the app's UI architecture. It introduces a BaseViewModel implementing the Model-View-Intent (MVI) pattern, providing reactive state flows, one-time effect handling, and a unified event dispatch mechanism. This is paired with a BaseScreen Composable that automatically connects the ViewModel to the UI, collecting state and effects while passing events back. The module also includes a FeatureNavigator interface for navigation abstraction, a NoOpNavigator for single-screen features, and a SearchDebounce utility with configurable durations for search flows.

common/presentation · high confidence

The Thread Violation feature now includes a set of new Compose UI components that define how violation data is presented to the user. TypeFilterChips provides a scrollable row for filtering violations by type (Disk Read, Disk Write, Network, Slow Call, Custom Slow Code). ViolationCard displays individual violation entries with their type, description, timestamp, and duration. ViolationDetailContent renders the detailed view, including violation metadata and a copyable stack trace. ViolationSummarySection shows aggregate counts for each violation type. ViolationTypeUi defines the color, icon, and abbreviation mappings for each violation type, ensuring consistent visual representation across the feature.

features/threadviolation/src/main/java/com/azikar24/wormaceptor/feature/threadviolation/ui/components · high confidence

The WebSocket feature now includes dedicated UI screens for browsing connections and viewing message details. The new WebSocketListScreen allows users to search, filter, and manage their WebSocket connections with a unified top bar, search input, and stats summary. The WebSocketDetailScreen provides a focused view for a selected connection, enabling message filtering by direction, real-time status indication, and message search. Both screens utilize the shared design system components (WormaCeptorTopBar, WormaCeptorSearchBar, WormaCeptorLoadableContent) and support IME padding for proper keyboard handling.

features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket/ui · high confidence

The viewer feature is now delivered via a dedicated module containing the main ViewerActivity, which enables edge-to-edge layout for Android 15+ compatibility and supports deep-link navigation to specific crash and transaction details. The activity integrates Koin for dependency injection, manages state for home, transaction, and crash lists, and handles user actions such as exporting data, sharing text, and copying to clipboard. A custom WormaCeptorFileProvider is included to prevent manifest merger conflicts with host apps that define their own FileProvider. Supporting use cases handle formatting of crash timestamps, HTTP headers, and detection of severe exception types.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer · high confidence

The app now includes a redesigned Welcome screen (WelcomeScreen) that displays a hero section, feature cards for Network, Crashes, and Tools, and action buttons, replacing the previous ShowcaseTab. Additionally, a new Test Tools sheet (TestToolsSheetContent) has been added to provide direct access to debugging utilities, including network tests (API, WebSocket), debug triggers (Crash, Memory Leak, Thread Violation), and feature tests (Location, WebView, Secure Storage), with visual status feedback via the new ToolStatus enum.

app/src/main/java/com/azikar24/wormaceptorapp/wormaceptorui/components · high confidence

This change adds the \recomposition.api\ file, which defines the public interface for the new Recomposition feature. Users and other modules can now access the \RecompositionNavigationContributor\ to integrate the feature's navigation, interact with the \RecompositionTracker\ to monitor recomposition metrics (such as count, rate, and session duration), and consume the \RecompositionViewModel\ and associated UI components (\RecompositionSummaryScreen\) to display performance data within the app.

features/recomposition/api · high confidence

This change adds a new feature module that enables real-time tracking of Jetpack Compose recomposition counts. It introduces a thread-safe singleton tracker that records events per composable, calculates rates, and identifies top recomposers. A new navigation contributor registers a summary screen that displays these metrics, using a dedicated use case to format durations and counts for the user. This functionality is designed to be available in debug builds to help developers identify performance bottlenecks, while remaining a no-op in release builds.

features/recomposition/src/main/java/com/azikar24/wormaceptor/feature/recomposition · high confidence

The Logs feature now supports advanced filtering via a query parser that allows users to include or exclude logs by tag, message, or both (e.g., 'tag:core', '-message:error'). Users can also filter by minimum log level, toggle specific levels, enable auto-scroll, and manage log capture (start/stop/clear). This change introduces the ViewModel and state management for these capabilities, replacing any previous ad-hoc filtering logic.

features/logs/src/main/java/com/azikar24/wormaceptor/feature/logs/vm · high confidence

New navigator interfaces (DatabaseNavigator, PreferencesNavigator, WebSocketNavigator) are added to define navigation contracts for their respective features, extending the common FeatureNavigator base. This change establishes a structured way for each feature module to declare its navigation capabilities, such as navigating to tables, query screens, preferences details, or WebSocket messages, and supports backward navigation.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database/navigator, features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/navigator, features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket/navigator · high confidence

The CPU feature now includes a dedicated screen (CpuScreen) that displays real-time CPU usage via an animated gauge, breaks down load across individual cores with animated progress bars, and visualizes historical usage trends in a line chart. The screen also shows system details such as CPU frequency, temperature, core count, and uptime, with warning indicators for high usage or temperature thresholds.

features/cpu/src/main/java/com/azikar24/wormaceptor/feature/cpu/ui · high confidence

The app now includes a new Device Information feature that displays comprehensive details about the device and application, including hardware specs, OS version, screen metrics, memory usage, storage status, and network connectivity. This feature is implemented using the MVI (Model-View-Intent) pattern with a dedicated navigation contributor, ViewModel factory, and use case for data collection. The implementation uses standard Android APIs to gather information without requiring special permissions (except ACCESS\_NETWORK\_STATE for network details).

features/deviceinfo/src/main/java/com/azikar24/wormaceptor/feature/deviceinfo · high confidence

The FPS feature now includes a dedicated UI screen that displays real-time frame rate data, including current FPS, average/min/max values, dropped frames, and jank frames. The interface features a scrollable layout with cards for current metrics, a history chart, and a monitoring status bar. Users can start/stop monitoring, reset statistics, and view warning badges when FPS drops below acceptable thresholds. The screen uses the app's design system tokens for consistent spacing and theming, and includes haptic feedback when resetting stats.

features/fps/src/main/java/com/azikar24/wormaceptor/feature/fps/ui · high confidence

The application now includes dedicated parsers for HTML and multipart form data content. The new HtmlBodyParser formats HTML with indentation, preserves structure for preformatted tags (like \<pre\>, \<script\>, and \<style\>), and extracts metadata. The MultipartBodyParser splits multipart data by boundary to extract individual parts, including their headers, names, filenames, and content types. These additions expand the range of content types the application can parse and display.

infra/parser/multipart · high confidence

The Loaded Libraries feature now includes a dedicated UI screen that displays a list of loaded libraries with support for searching, filtering by type (Native SO, DEX, JAR, AAR), and viewing detailed information in a bottom sheet. The interface uses the app's design system tokens for consistent theming and includes a summary section, filter controls, and an animated search bar. Library cards display type-specific icons and color-coded badges, while the detail view provides comprehensive information about each selected library.

features/loadedlibraries/src/main/java/com/azikar24/wormaceptor/feature/loadedlibraries/ui · high confidence

The Memory feature now includes a dedicated UI screen (MemoryScreen.kt) that displays real-time memory metrics, including heap usage, native heap status, and a historical chart. The layout supports edge-to-edge rendering on Android 15+ by explicitly handling navigation bar insets and using design tokens for spacing. Users can interact with the screen via action buttons (e.g., Force GC) and view monitoring status through a dedicated status bar component.

features/memory/src/main/java/com/azikar24/wormaceptor/feature/memory/ui · high confidence

The Rate Limit feature now includes a set of new Compose UI components (ConfigurationCard, EnableToggleCard, NetworkPresetsCard, StatisticsCard) that present network throttling settings, presets, and live statistics. These components adopt the app's semantic design tokens (WormaCeptorTokens) for consistent styling and colors, replacing previous hardcoded or generic styling approaches.

features/ratelimit/src/main/java/com/azikar24/wormaceptor/feature/ratelimit/ui/components · high confidence

The Rate Limit feature now presents a dedicated UI screen (RateLimitScreen) that allows users to enable/disable rate limiting, view throttle statistics, select network presets, and configure custom download/upload speeds, latency, and packet loss. This screen is built using the MVI pattern (exposing RateLimitViewState and handling RateLimitViewEvents) and integrates with the shared design system via WormaCeptorTopBar, WormaCeptorIconButton, and WormaCeptorTokens for consistent theming and spacing.

features/ratelimit/src/main/java/com/azikar24/wormaceptor/feature/ratelimit/ui · high confidence

The \infra/persistence/sqlite/api\ module now exposes the public API contracts for the new Room-based persistence layer. This includes DAO interfaces and implementations for \CrashDao\ and \LeakDao\, entity classes (\CrashEntity\, \LeakEntity\) with domain conversion methods, and in-memory repository stubs for crash, leak, location simulator, push simulator, transaction, and WebView monitor data. It also defines \Converters\ for serializing complex types (dates, UUIDs, maps) and \BlobStorage\ implementations for file handling, establishing the foundational data access layer for these features.

infra/persistence/sqlite/api · high confidence

The UI layer now includes a set of helper utilities to improve user experience and code consistency. Users benefit from safer clipboard operations via \copyToClipboardWithSizeCheck\, which prevents failures on large text by returning a warning instead of copying silently. Display logic is enhanced with new formatters for timestamps, durations, and file sizes, ensuring consistent presentation of time and data across the app. Additionally, \clickableWithoutRipple\ allows for custom interactive elements without the default ripple effect, and \contentColorFor\ provides a quick way to determine high-contrast text colors for UI elements like badges and chips.

core/ui/src/main/java/com/azikar24/wormaceptor/core/ui/util · high confidence

The build-logic module now introduces a suite of new Gradle convention plugins to standardize module configurations and enable library distribution. New plugins include wormaceptor.android.library (targeting SDK 36, minSdk 23, Java 17), wormaceptor.android.compose (adding Jetpack Compose BOM 2024.10.01 and core UI dependencies), wormaceptor.android.feature (adding Koin, lifecycle-viewmodel-compose, and KSP support), and wormaceptor.jvm.library (for pure Kotlin/JVM modules). Additionally, the wormaceptor.publishing plugin configures these modules for signed publication to Maven Central via the Vanniktech Maven Publish plugin, handling POM metadata and providing an empty Javadoc JAR to bypass AGP 8.6.0's Dokka/ASM compatibility issues with sealed classes.

build-logic · high confidence

A new \common:presentation\ module has been added, introducing \BaseViewModel\ and \BaseScreen\ as foundational components for the application's UI layer. \BaseViewModel\ provides a structured approach to state management and effect handling via \StateFlow\ and \SharedFlow\, along with a \FeatureNavigator\ interface for navigation. \BaseScreen\ offers a Compose-based wrapper that integrates with the view model. The module also includes a \NoOpNavigator\ implementation and \SearchDebounce\ constants for common UI patterns, establishing a standardized architecture for future screens.

common · high confidence

The core engine module now includes a suite of new components that provide foundational capabilities for network transaction capture (CaptureEngine), real-time performance monitoring via CPU (CpuMonitorEngine) and FPS (FpsMonitorEngine) metrics, memory leak detection (LeakDetectionEngine), and dynamic dependency inspection (DependenciesInspectorEngine). Additionally, it introduces a cryptographic operations engine (CryptoEngine), a crash reporter (CrashReporter), and a flexible parsing and highlighting infrastructure (DefaultParserRegistry, HighlighterRegistry, ExtensionRegistry) to support extensible network data analysis.

core/engine/src/main · high confidence

The viewer feature now includes dedicated export functionality for both application crashes and network traffic. Users can export crash reports as JSON files via the system share sheet. Additionally, network transactions can be exported in JSON or HAR 1.2 formats; large exports are automatically saved as files and shared via URI, while smaller ones are shared as text content. This introduces new components in the export package, including CrashExport, ExportManager, and HarExporter, to handle serialization and sharing logic.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/export · high confidence

The preferences feature now includes a new data layer that allows users to view, edit, and manage the app's internal SharedPreferences. This change introduces a data source that reads and writes preference files (XML) and a repository implementation that exposes this data via Kotlin Flows. Users can now observe changes to preference files and items in real-time, with the repository handling background threading and listener management for file and item updates.

features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/data · high confidence

The app now includes a new data layer for browsing local SQLite databases. The DatabaseDataSource class provides read-only access to databases found in the app's data directory, allowing users to list databases, view table schemas, and query table data with pagination. The DatabaseRepositoryImpl wraps this data source to expose these capabilities through the domain contract, enabling the new Database Browser feature.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database/data · high confidence

This change introduces a comprehensive set of repository interfaces and parsing contracts for the WormaCeptor application, enabling features like network transaction management, SQLite database browsing, file system access, crash/leak monitoring, and custom extension providers. It also adds contract interfaces for body parsing (including JSON, XML, Protobuf, and multipart), syntax highlighting, and image metadata extraction. Additionally, baseline configuration files for detekt and lint have been added to the contracts module to manage code quality checks.

domain/contracts · high confidence

This change introduces a comprehensive set of new domain entities in the \domain/entities\ module to support WormaCeptor's debugging and inspection capabilities. The new data models include \DeviceInfo\ and \CpuInfo\ for system and hardware metrics, \DependencyInfo\ and \LoadedLibrary\ for library detection, \CryptoConfig\ and \CryptoResult\ for cryptographic operations, \FileInfo\ and \FileContent\ for file browsing, and \LeakInfo\ for memory leak reporting. Additionally, \detekt-baseline.xml\ and \lint-baseline.xml\ files have been added to suppress existing static analysis warnings for these new and existing classes, ensuring clean builds while the codebase matures.

domain/entities · high confidence

A new glitch effect has been added to the application, implemented via a custom RuntimeShader (AGSL) for Android 13+ with a Compose-based fallback for older versions. The effect includes configurable parameters for animation duration, shake intensity, rotation, noise density, and scanline appearance, controlled through the new GlitchConstants object.

app/src/main/java/com/azikar24/wormaceptorapp/wormaceptorui/effects · high confidence

The viewer module now includes dedicated UI components for previewing images and PDFs within HTTP responses. ImagePreviewCard displays image thumbnails with metadata (dimensions, format, size) and provides options to download, share, or open in a new FullscreenImageViewer, which supports pinch-to-zoom, double-tap zoom, and swipe-to-dismiss. Similarly, PdfPreviewCard renders PDF thumbnails, shows document metadata, and handles various load states including loading, error, and password-protected documents, with actions to download or share. These components integrate with the existing WormaCeptor design system tokens for consistent styling.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/ui/components · high confidence

The image parser module now supports detecting and extracting metadata for PNG, JPEG, GIF, WebP, BMP, ICO, and SVG formats. It identifies formats using magic byte signatures (falling back when Content-Type headers are missing) and extracts details such as dimensions, color space, alpha channel presence, and bit depth without relying on external image libraries. This enables the application to display structured image information in the viewer.

infra/parser/image · high confidence

Added LocationMapCard and LocationMapView composables to display real and mock device locations on an OpenStreetMap. The map view integrates with the WormaCeptorTokens design system for consistent styling (borders, shapes, colors) and provides visual indicators for active mock locations, including animated borders and distinct markers for real vs. mock positions.

features/location/src/main/java/com/azikar24/wormaceptor/feature/location/ui/components · high confidence

The Logs feature now includes dedicated UI components for filtering and viewing log entries. Users can filter logs by severity level using the new LevelFilterChips, which display counts and support overflow formatting. Log entries are rendered in a scrollable list using the LogList component, with each entry displayed in an outlined card showing the level, tag, timestamp, and message. A StatsBar component provides real-time status indicators for log capture state, process ID, and entry counts.

features/logs/src/main/java/com/azikar24/wormaceptor/feature/logs/ui/components · high confidence

The Device Info feature now exposes a stable public API, making its core components accessible to other modules. This includes the navigation contributor for integrating the screen into the app's navigation graph, a ViewModel factory for dependency injection, and the \GetDeviceInfoUseCase\ for retrieving device details. The API also exposes the UI composable (\DeviceInfoScreenContent\), the view model state and event models (supporting actions like copying sections, sharing reports, and refreshing), and the specific data sections (Application, Device, Display, Memory, Network, OS, Storage) that can be displayed.

features/deviceinfo/api · high confidence

The viewer now provides dedicated, structured UI components for displaying various request body formats. Users can view JSON and XML as syntax-highlighted, collapsible trees; form data as a key-value table; multipart uploads as an accordion of parts with file/image indicators; and Protobuf data as a list of decoded fields with a hex-dump fallback. A new ContentTypeChip component visually identifies the detected content type using semantic colors and icons.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/ui/components/body · high confidence

Added LocationTestScreen, SecureStorageTestScreen, and WebViewTestScreen to the app's test UI. The Location test screen displays a live map using OSMDroid, shows current location status (real vs. mocked), and provides a button to open the mock location tool. The Secure Storage test screen allows users to manage and view encrypted preferences and KeyStore entries via a tabbed pager interface with a speed dial FAB for adding data. The WebView test screen renders a monitored WebView instance with buttons to load HTML, JSON, and image URLs, enabling verification of web content handling and monitoring.

app/src/main/java/com/azikar24/wormaceptorapp/screens · high confidence

The viewer module now includes a new set of UI utilities that enhance how users interact with request data. Users can now share large request or response bodies as files via the Android share sheet, with background processing and immediate loading feedback to prevent UI blocking. A new cURL generator creates shell-safe commands from HTTP transaction data, protecting against injection by sanitizing methods and quoting values. Additionally, image operations are supported through utilities that allow saving images to the device gallery (handling both modern and legacy storage APIs) and sharing images via the system share sheet.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/ui/util · high confidence

The Preferences module now provides two new UI screens: a list view for browsing preference files and a detail view for editing individual preferences. Both screens integrate the shared WormaCeptor design system, utilizing components like WormaCeptorTopBar, WormaCeptorSearchBar, and WormaCeptorLoadableContent for consistent styling and loading states. Users can now search within the file list and toggle search in the detail view, with keyboard input handling improved via imePadding to prevent layout shifts on Android devices.

features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/ui · high confidence

The \features/dependenciesinspector/api\ module now exposes the public contract for the Dependencies Inspector feature. This includes the \DependenciesInspectorNavigationContributor\ for routing, the \DependenciesInspectorViewModelFactory\ for dependency injection, and the core UI composable \DependenciesInspectorScreen\. The API also defines the MVI state management structures, including \DependenciesInspectorViewState\ (containing dependency lists, summaries, and search filters) and \DependenciesInspectorViewEvent\ (covering actions like selecting a dependency, setting search queries, filtering by category, and toggling search). This entry documents the specific API surface added in this location, which enables other parts of the application to integrate and consume the inspector.

features/dependenciesinspector/api · high confidence

The \features/memory/api\ module now exposes the public API for the Memory feature, including the \MemoryNavigationContributor\ for navigation integration, the \MemoryViewModelFactory\ for dependency injection, and the \MemoryScreen\ composable along with its sub-components (ActionButtons, ChartCard, TopAppBar, NativeHeapCard). The API also exposes the MVI state management classes (\MemoryViewState\, \MemoryViewEvent\, \MemoryViewEffect\) and the \MemoryViewModel\, enabling other modules to consume the memory monitoring UI and logic.

features/memory/api · high confidence

The push token feature now exposes its public API contract, defining the navigation contributor, view model factory, and UI composables. Users can now interact with push tokens through a screen that displays the current token, a history of past tokens, and actions to copy, delete, or refresh tokens, with state management handled by the PushTokenViewModel.

features/pushtoken/api · high confidence

The location feature now presents a structured, scrollable UI for managing mock locations. Users can input custom coordinates with real-time validation, toggle mock location status via a dedicated status card, and save frequently used coordinates as named presets. The interface includes a collapsible map section to visualize real and mock locations, a search bar to filter presets, and a warning banner that guides users to enable developer options if mock location support is unavailable.

features/location/src/main/java/com/azikar24/wormaceptor/feature/location/ui · high confidence

The repository is initialized with essential infrastructure files: an .editorconfig for consistent code formatting, a .gitleaks.toml for secret detection, a .lefthook.yml for pre-commit and pre-push hooks (spotless, detekt, lint), a LICENSE (MIT), and a README.md with installation and usage instructions. Build tooling is updated with a new jitpack.yml, a keystore.properties.example, and a lint.xml. The .gitignore is expanded to exclude IDE settings, signing keys, and release builds. The gradlew and gradlew.bat scripts are updated to a newer POSIX-compliant version.

(repo-wide) · high confidence

The SQLite persistence module now provides the complete data layer for the WormaCeptor debugging tool. It introduces Room-based DAOs and entities for crash reports, memory leaks, location simulator presets, push notification templates, and mock HTTP rules, along with a migration from schema version 6 to 7 to create the mock\_rules table. Complex domain types (dates, UUIDs, enums, maps, and lists) are persisted via Room type converters using kotlinx.serialization. A KeystoreKeyManager generates a device-bound passphrase for the SQLCipher database. For non-persistent debug builds, the module supplies in-memory implementations of all repositories (transactions, crashes, leaks, location, push, and WebView monitoring), including built-in city presets for location simulation and preset notification templates for push testing. Blob storage is supported via both file-system and in-memory backends, and code-quality baselines (detekt and lint) have been added to suppress known issues in the new code.

infra/persistence/sqlite · high confidence

The sample service now demonstrates JSON body redaction by configuring the interceptor to redact the 'password' field in login requests, and it includes new endpoints and mock interceptors to test viewing of Protobuf, PDF, and various image formats (PNG, WebP, GIF) alongside existing JSON, XML, and HTML support.

app/src/main/java/com/azikar24/wormaceptorapp/sampleservice · high confidence

The public API for the Secure Storage feature module is now exposed, defining the navigation contributor, ViewModel factory, and UI composable entry points. This includes the SecureStorageScreen composable for rendering the interface, along with the underlying MVI state management classes (SecureStorageViewState, SecureStorageViewEvent, SecureStorageViewEffect) and specific events for selecting entries, filtering by type, and updating search queries.

features/securestorage/api · high confidence

The application now includes syntax highlighters for JSON and XML files. The JSON highlighter distinguishes property keys, string values, numbers, booleans, null, and punctuation. The XML highlighter tokenizes tag names, attribute names and values (supporting double-quoted, single-quoted, and unquoted values), comments, CDATA sections, DOCTYPE declarations, XML declarations, processing instructions, and entity references. This enables proper visual formatting for these file types within the editor.

infra/syntax/xml · high confidence

The WebView Monitor feature now includes a complete set of UI components for its list screen, including a top bar with search and clear actions, an expandable search bar, a scrollable filter row for resource types, a stats summary row, and a list of request items displaying method, path, host, status, and metadata. These components use the app's design tokens and semantic colors for consistent styling.

features/webviewmonitor/src/main/java/com/azikar24/wormaceptor/feature/webviewmonitor/ui/components · high confidence

The in-memory data storage layer for the WormaCeptor-IMDB module has been removed. This change deletes the \WormaCeptorIMDB\ singleton, the \TransactionDao\ implementation, and the underlying \SimpleTransactionDataStore\ along with its associated LiveData and Paging data sources. Users relying on this specific in-memory storage mechanism for HTTP transactions will no longer have access to this data persistence method within this module.

WormaCeptor-imdb · high confidence

The legacy no-op implementation (WormaCeptor-no-op) and the Room-based persistence layer (WormaCeptor-persistence) have been removed. This deletes the stub classes that previously returned null or empty storage, as well as the database entities, DAOs, and type converters used to persist HTTP transactions to a local Room database. Users relying on this specific local storage mechanism will no longer have transaction data persisted in this manner.

WormaCeptor-no-op, WormaCeptor-persistence · high confidence

The \VeryLargeData\ class, which was used to generate a large string of sample text for testing or demonstration purposes, has been removed from the sample service. This eliminates the overhead associated with initializing a large in-memory string during the class construction.

app/src/main/java/com/azikar24/wormaceptor/sampleservice · high confidence

The WormaCeptor library module has been completely removed from the project. This deletion eliminates the HTTP traffic interception capabilities, the associated data models (HttpTransaction, HttpHeader), the local storage layer (Room/TransactionDao), the UI helper classes, and the background services (ClearTransactionsService, DismissNotificationService) that previously powered the network debugging features.

WormaCeptor · high confidence

The Loaded Libraries feature now exposes its public API contract, defining the navigation contributor, ViewModel factory, and UI composable entry points. This includes the public interfaces for view events (such as selecting a library, refreshing, or toggling search) and the view state structure, enabling other modules to integrate with and consume the feature's presentation layer.

features/loadedlibraries/api · high confidence

The Leak Detection module now publishes its public API surface, defining the navigation contributor, ViewModel factory, and UI composables. This exposes the feature's state management (view state and events like selecting leaks or filtering by severity) and UI components (screen, leak cards, detail content, and severity filter chips) for external integration and navigation.

features/leakdetection/api · high confidence

The location feature now exposes its public API contract, defining the navigation contributor, ViewModel factory, and the MVI (Model-View-Intent) state management structure. Users interacting with the location module will see a defined set of view events for managing mock locations, such as updating latitude/longitude, saving or deleting presets, and clearing mock states, alongside view effects for displaying success or error messages. The UI layer exposes composables for the main location screen, map views, and input sections, establishing the boundary for how location simulation and preset management are presented.

features/location/api · high confidence

The \features/viewer/api\ location now contains a generated API dump (\viewer.api\) that exposes the public contract of the viewer feature. This file documents the public classes and methods available to consumers, including the \ViewerActivity\, \WormaCeptorFileProvider\, \FavoritesRepository\ for managing user favorites, \ExportManager\ and \HarExporter\ for transaction and crash data export, \DeepLinkHandler\ for navigation to crashes, tools, and transactions tabs, and various UI composables for the crash detail, crash list, filter, home, and tools screens.

features/viewer/api · high confidence

The core engine's public API surface has been updated to expose the full set of engine components, including CaptureEngine, CoreHolder, CpuMonitorEngine, CrashReporter, CryptoEngine, DependencyInspectorEngine, FpsMonitorEngine, LeakDetectionEngine, and various registry implementations (Extension, Highlighter, Parser). This change makes the internal engine logic and monitoring capabilities (CPU, FPS, memory leaks, crypto operations) directly accessible via the public API contract, allowing external consumers to initialize, configure, and interact with these services.

core/engine/api · high confidence

The public API for the Preferences feature is now explicitly defined and versioned, exposing the navigation contributor, ViewModel factory, data source, repository implementation, and UI composables (list, detail, and edit sheet) for external consumption or testing. This change ensures that the core logic for managing preference items, including their CRUD operations and state management via \PreferenceEditorState\, is accessible through a stable contract, facilitating integration and reducing the risk of breaking changes in dependent modules.

features/cpu/api, features/crypto/api, features/preferences/api · high confidence

The \contracts.api\ file has been added to define the public API surface for the domain contracts module. This file explicitly declares the stable interfaces and classes available to consumers, including \BaseBodyParser\, \BlobStorage\, \BodyParser\, \ContentType\ (with its various image and data types), \CrashRepository\, \DatabaseRepository\, \ExtensionContext\, \ExtensionProvider\, \FeatureConfig\, \FeatureConfigRepository\, \FileSystemRepository\, \FormDataParser\, \ImageMetadataExtractor\, \LeakRepository\, \LocationSimulatorRepository\, \MockRuleRepository\, \MultipartParser\, and \ParsedBody\. This establishes the contract boundary for these domain components.

domain/contracts/api · high confidence

The \core/ui/api/ui.api\ file has been added, establishing the public API surface for the WormaCeptor UI library. This change exposes the signatures for core components including the top bar, various badge variants (Filled, Soft, Tonal), buttons (Primary, Secondary, Outlined, Destructive, Text), and floating action buttons (FAB, Extended FAB, Small FAB), ensuring these elements are part of the stable public contract for consumers of the library.

core/ui/api · high confidence

The Push Simulator feature now exposes a public API surface that includes the navigation contributor for integrating the simulator screen into the app's navigation graph, a ViewModel factory for dependency injection, and the public contracts for the Model-View-Intent (MVI) state management. This includes the definition of view events (such as adding actions, clearing forms, deleting templates, and dismissing permission dialogs) and view effects (such as error states, notification sent confirmations, and template load/save/delete status), enabling external modules to interact with the Push Simulator's UI logic and state transitions.

features/pushsimulator/api · high confidence

The public API for the Thread Violation feature has been established, exposing the navigation contributor, ViewModel factory, and UI composable entry points. Users and integrators can now interact with the feature's state management via the new \ThreadViolationViewState\ and event types (such as \SelectType\, \SelectViolation\, \ToggleMonitoring\, \ClearViolations\, and \DismissDetail\), enabling programmatic control over violation monitoring and detail views within the application.

features/threadviolation/api · high confidence

The public API for the WebSocket feature module has been generated, exposing the navigation contributor, ViewModel factory, and navigation graph composable. The API defines the user interaction model through view events such as selecting connections, toggling direction filters, expanding messages, and confirming or dismissing clear actions, alongside the corresponding view effects and navigator interface for back and message navigation.

features/logs/api, features/websocket/api · high confidence

The infra/parser module now publishes stable public API files (form.api, html.api, image.api, json.api, multipart.api, pdf.api, protobuf.api, xml.api) that document the public contracts of each body parser, alongside detekt and lint baseline files to suppress known code-quality warnings. This change establishes a formal API surface for the parser infrastructure and configures static-analysis baselines, ensuring future changes to these parsers are tracked and validated against consistent quality standards.

infra/parser · high confidence

This change introduces API signature files (\.api\) and code-quality baselines (lint and detekt) for the \imdb\, \no-op\, and \persistence\ modules within the API implementation layer. These additions establish a baseline for public API stability and suppress known code-smell warnings (such as long methods and magic numbers in \ServiceProviderImpl\) to facilitate cleaner code reviews and automated quality checks. Additionally, ProGuard rules were added to the persistence module to preserve SQLCipher native classes, ensuring the encrypted database library functions correctly when code is obfuscated.

api/impl · high confidence

The core/ui module now includes a consumer-rules.pro file that preserves FeatureNavigationContributor implementations to ensure ServiceLoader-based navigation discovery works correctly in release builds. Additionally, new detekt-baseline.xml and lint-baseline.xml files have been added to suppress existing static analysis warnings, allowing the build to proceed without blocking on current code quality issues.

core/ui · high confidence

The app now initializes the WormaCeptor SDK upon startup with crash logging enabled and all features turned on. It also registers a test extension provider that exposes response availability and a custom tag to the SDK.

app/src/main/java/com/azikar24/wormaceptorapp · high confidence

The CPU monitoring feature now uses a Model-View-Intent (MVI) pattern, introducing CpuViewModel that extends BaseViewModel to manage state via CpuViewState and handle user actions through CpuViewEvent (StartMonitoring, StopMonitoring, ClearHistory). Side effects are exposed via the new CpuEffect sealed class, and the ViewModel combines real-time CPU metrics, history, and monitoring status from CpuMonitorEngine to update the UI state.

features/cpu/src/main/java/com/azikar24/wormaceptor/feature/cpu/vm · high confidence

The app now uses a unified design token system (WormaCeptorTokens) to manage colors, spacing, typography, and dimensions. This change introduces a centralized palette and semantic color layers that support both light and dark themes, ensuring consistent visual styling across all tools and features. It also adds a \rememberReduceMotion\ utility to respect the system's 'Reduce Motion' accessibility setting, automatically suppressing animations for users who prefer reduced motion. Additionally, a density scaling system allows the UI layout to adapt to compact, default, or expanded spacing preferences.

core/ui/src/main/java/com/azikar24/wormaceptor/core/ui/theme/tokens · high confidence

The navigation system has been refactored to centralize all route definitions in WormaCeptorNavKeys and enable modular feature integration via the new FeatureNavigationContributor interface and FeatureRegistry. This allows individual feature modules to register their own navigation destinations automatically using ServiceLoader, while the app now applies consistent slide-and-fade page transitions across all screens using the new WormaCeptorNavTransitions component.

core/ui/src/main/java/com/azikar24/wormaceptor/core/ui/navigation · high confidence

The Crypto module has been refactored to use the MVI (Model-View-Intent) pattern, introducing a new \CryptoViewModel\ and \CryptoNavigationContributor\ to manage state and navigation. The UI has been rebuilt using the shared \WormaCeptor\ design system, replacing hardcoded colors and layouts with semantic tokens and reusable components like \WormaCeptorTopBar\ and \WormaCeptorContainer\. This change standardizes the crypto tool's appearance and behavior across the app, ensuring consistent styling and a unified user experience.

features/crypto/src/main/java/com/azikar24/wormaceptor/feature/crypto · high confidence

The persistence layer now uses SQLCipher to encrypt the local Room database. For existing users, the application automatically detects unencrypted SQLite databases and performs an in-place migration to the encrypted format, preserving all data. This process involves creating a temporary encrypted database, copying the schema and data from the plaintext version, and then swapping the files, with backups created if the migration fails.

api/impl/persistence · high confidence

The public API for the database feature has been regenerated to expose the new internal structure, including the \DatabaseNavigationContributor\ for route registration, the \DatabaseViewModelFactory\ for dependency injection, and the \DatabaseDataSource\ and \DatabaseRepositoryImpl\ for data access. The UI layer now exposes specific Composable functions (\DatabaseListScreen\, \QueryScreen\, \TableDataScreen\, \TableListScreen\) that consume the new \DatabaseViewState\ and event types (\DatabaseViewEvent\), reflecting the migration to an MVI pattern with distinct effects like \ShowError\ and events for pagination and schema toggling.

features/database/api · high confidence

The Database Browser's view model has been refactored to follow the Model-View-Intent (MVI) pattern, introducing explicit sealed classes for state (DatabaseViewState), user actions (DatabaseViewEvent), and side effects (DatabaseViewEffect). This change structures how the database list, table list, data grid, and SQL query editor manage their UI state and user interactions, replacing the previous implementation with a more predictable flow for loading data, handling search queries, and navigating between database views.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database/vm · high confidence

The database feature's navigation entry point has been refactored to centralize route definitions within a dedicated \databaseGraph\. This change introduces a graph-scoped ViewModel pattern, ensuring that the \DatabaseViewModel\ is shared across the database list, tables, table data, and query screens rather than being recreated for each destination. Users benefit from a more consistent state management experience when navigating between these database-related views, as the ViewModel lifecycle is now tied to the navigation graph itself.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database/navigation · high confidence

The Dependencies Inspector feature now uses a Model-View-Intent (MVI) pattern, introducing a dedicated ViewModel that manages UI state and user interactions. Users can filter dependencies by category, toggle version-only views, search by name or package, and select individual dependencies for details. The ViewModel exposes a text export function for sharing dependency summaries and handles loading and error states via a consolidated state object.

features/dependenciesinspector/src/main/java/com/azikar24/wormaceptor/feature/dependenciesinspector/vm · high confidence

The Device Info screen has been refactored to use the Model-View-Intent (MVI) pattern, introducing structured state management and explicit error handling for a more reliable user experience. The UI now utilizes the shared WormaCeptorTopBar and WormaCeptorIconButton components, ensuring visual consistency across the app, while supporting pull-to-refresh and copy/share actions for device details.

features/deviceinfo/src/main/java/com/azikar24/wormaceptor/feature/deviceinfo/ui · high confidence

The Device Info feature's UI components (App, Device, Memory, Network, OS, Screen, and Storage sections) have been updated to use the new WormaCeptorTokens semantic API for styling. This change ensures consistent visual theming across the feature by applying semantic colors, spacing, and shapes defined in the core design system, replacing previous direct color or style references.

features/deviceinfo/src/main/java/com/azikar24/wormaceptor/feature/deviceinfo/ui/components · high confidence

The device info feature has been restructured to use an MVI architecture, introducing the ability for users to copy specific sections of the device report (such as hardware, OS, display, memory, storage, app details, and network status) to the clipboard, as well as copy the entire report or share it via the system share sheet. The screen also supports pull-to-refresh to reload device data and displays error messages if loading fails.

features/deviceinfo/src/main/java/com/azikar24/wormaceptor/feature/deviceinfo/vm · high confidence

The FPS Monitor feature's view layer has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state management approach where the UI state (current FPS, history, monitoring status, and warning flags) is consolidated into a single immutable state object, user actions are explicitly defined as events (start, stop, toggle, reset), and side effects are handled via a sealed class. This change ensures that the monitoring state is managed consistently by the underlying engine and exposed predictably to the UI.

features/fps/src/main/java/com/azikar24/wormaceptor/feature/fps/vm · high confidence

The FPS feature module now exposes a public API surface defining its navigation contribution, ViewModel factory, and UI composables. This change formalizes the feature's integration into the app's navigation graph and implements the Model-View-Intent (MVI) pattern, exposing specific view states (current FPS info, history, warning/monitoring flags) and events (start, stop, toggle, reset) for the FPS monitoring screen.

features/fps/api · high confidence

The FPS feature's UI components (CurrentFpsCard, DroppedFramesCard, FpsChartCard, StatisticsRow) have been migrated to use the WormaCeptor design system. This includes adopting the Outlined card style, applying WormaCeptorTokens for shapes, spacing, and typography, and utilizing semantic color tokens for status indicators (Excellent, Moderate, Poor, Idle). The FpsChartCard now uses a Canvas-based chart with configurable thresholds and legend items, while DroppedFramesCard includes animated visibility for jank warnings. All components support light/dark themes via WormaCeptorTheme previews.

features/fps/src/main/java/com/azikar24/wormaceptor/feature/fps/ui/components · high confidence

The file browser feature now exposes a stable public API surface (\filebrowser.api\) defining the navigation contributor, ViewModel factory, and data layer interfaces. This change introduces an MVI (Model-View-Intent) architecture for the file browser, exposing specific view events such as file deletion, path copying, and file selection, along with view effects for navigation and snackbars. Users interacting with the file browser will now have their actions handled through this structured state management pattern, which standardizes how file system operations (listing, reading, deleting) are exposed via the \FileSystemDataSource\ and \FileSystemRepositoryImpl\.

features/filebrowser/api · high confidence

The file browser's ViewModel has been refactored to follow the Model-View-Intent (MVI) pattern, introducing distinct sealed classes for user events (FileBrowserViewEvent) and one-time side effects (FileBrowserViewEffect). This change structures how the UI interacts with the logic: user actions like navigating directories, changing sort modes, or searching are now explicit events, while UI feedback such as showing snackbars or handling root-navigation limits are emitted as effects. The ViewModel now manages state transitions for loading roots, browsing directory stacks, and handling file interactions through this typed contract, replacing the previous implementation.

features/filebrowser/src/main/java/com/azikar24/wormaceptor/feature/filebrowser/vm · high confidence

The app now uses a unified design system defined in the core UI module. A new \WormaCeptorTheme\ composable serves as the single entry point for applying the Material 3 color schemes (including dynamic color support on Android 12+), typography, and window insets. This theme provides a \density\ parameter that allows the entire UI to scale spacing and sizing via a new \TokenDensity\ system. All visual properties are now accessed through the centralized \WormaCeptorTokens\ object, which exposes structured tokens for colors (status, charts, tools, semantic, syntax), spacing, radii, elevation, animations, and component sizes, replacing scattered hardcoded values with a consistent, theme-aware API.

core/ui/src/main/java/com/azikar24/wormaceptor/core/ui/theme · high confidence

The Secure Storage feature now uses a set of new, standardized UI components for displaying and filtering storage entries. EntryCard presents individual secure storage items with encryption status and storage type badges, while EntryDetailContent provides a structured view of entry metadata. SummarySection displays aggregate counts for Encrypted SharedPrefs, Keystore, and DataStore entries with accessibility indicators, and TypeFilterChips allows users to filter the list by storage type using a scrollable row of chips. These components adopt the WormaCeptor design tokens for consistent theming and spacing.

features/securestorage/src/main/java/com/azikar24/wormaceptor/feature/securestorage/ui/components · high confidence

The Android platform module now publishes a formal API surface file (android.api) that exposes the public contracts for FloatingButtonService and ShakeDetector, ensuring stable external interfaces for these components. Additionally, detekt and lint baseline files have been added to suppress known code-quality issues (such as complexity and style warnings in FloatingButtonService) and to record the current lint state, allowing the build to pass while these specific issues are tracked.

platform · high confidence

The app now uses a consolidated set of core UI primitives—WormaCeptorTopBar, WormaCeptorButton, WormaCeptorCard, WormaCeptorBadge, WormaCeptorFAB, and WormaCeptorIconButton—enforcing consistent styling, spacing, and interaction patterns across the interface. This standardization ensures that elements like top app bars, buttons, cards, and badges share a single rendering path, improving visual coherence and maintainability.

core/ui/src/main/java/com/azikar24/wormaceptor/core/ui/components · high confidence

The Leak Detection screen has been rewritten to use the app's shared design system components, including WormaCeptorTopBar, WormaCeptorIconButton, and WormaCeptorLoadableContent, ensuring visual consistency across the app. It now follows the MVI (Model-View-Intent) pattern, managing state via LeakDetectionViewState and handling user interactions through LeakDetectionViewEvent. The UI also integrates edge-to-edge layout support for Android 15+ and uses design tokens for spacing and colors.

features/leakdetection/src/main/java/com/azikar24/wormaceptor/feature/leakdetection/ui · high confidence

The leak detection feature's UI components (LeakCard, LeakDetailContent, LeakSummarySection, SeverityFilterChips) have been rewritten to use the shared WormaCeptor design system. This introduces consistent styling via WormaCeptorTokens for shapes, spacing, and semantic colors, replacing previous local implementations. Users will see a unified visual style across the app, with severity-based color coding for leaks and standardized card/chip layouts.

features/leakdetection/src/main/java/com/azikar24/wormaceptor/feature/leakdetection/ui/components · high confidence

The Leak Detection module has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state management approach where user interactions (such as selecting a leak severity, triggering a check, or clearing results) are handled as explicit events, and the UI state is derived from a single source of truth. The view model now manages leak filtering, summary updates, and loading states through immutable state objects, providing a more predictable and testable flow for the leak detection experience.

features/leakdetection/src/main/java/com/azikar24/wormaceptor/feature/leakdetection/vm · high confidence

The leak detection module has been refactored to follow the Model-View-Intent (MVI) pattern, introducing a dedicated navigation contributor and a specific ViewModel factory. This change standardizes how the feature integrates with the app's navigation graph and manages its state, ensuring consistent behavior with other migrated modules.

features/leakdetection/src/main/java/com/azikar24/wormaceptor/feature/leakdetection · high confidence

The Loaded Libraries Inspector has been refactored to use the Model-View-Intent (MVI) pattern. This change introduces a structured state management approach where user actions (such as filtering by type, toggling system libraries, searching, or selecting a library) are handled as explicit events, and the UI state is derived from a single source of truth. This ensures consistent behavior for filtering, searching, and detail selection within the loaded libraries view.

features/loadedlibraries/src/main/java/com/azikar24/wormaceptor/feature/loadedlibraries/vm · high confidence

The Location and WebView test screens have been restructured to follow the Model-View-Intent (MVI) pattern. The Location test screen now explicitly manages location permissions, starts/stops GPS and network updates, and detects mock locations, exposing these behaviors through dedicated state and effect classes. The WebView test screen now handles URL loading events and navigates to specific test URLs (HTML, JSON, image) via httpbin.org, also using a strict MVI structure for state and navigation effects.

app/src/main/java/com/azikar24/wormaceptorapp/screens/location, app/src/main/java/com/azikar24/wormaceptorapp/screens/webview · high confidence

The location simulation feature's view model has been restructured to follow the Model-View-Intent (MVI) architecture. This introduces explicit sealed classes for user events (LocationViewEvent), UI state (LocationViewState), and one-time side effects (LocationViewEffect), replacing the previous state management approach. Users benefit from a more predictable and stable interaction model when managing mock locations, presets, and coordinate inputs, as state changes are now handled through a unidirectional data flow.

features/location/src/main/java/com/azikar24/wormaceptor/feature/location/vm · high confidence

The ViewModels in the viewer feature (Home, Transaction List, Transaction Detail, Crash List, and PDF Viewer) have been refactored to follow the MVI pattern using the BaseViewModel base class. This introduces explicit, sealed-class contracts for Events (user actions), States (UI data), and Effects (one-time side-effects like navigation or snackbars), replacing the previous ad-hoc state management. The diff also adds supporting data classes like BinaryPayload and BodySectionState to handle value-based equality for byte arrays and shared body section UI state.

features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/vm · high confidence

The main application screen has been refactored to use the Model-View-Intent (MVI) pattern, introducing new UI model classes (MainViewState, MainViewEvent, MainViewEffect) and a MainViewModel to manage state and navigation. This change consolidates the behavior for the test tools hub, allowing users to trigger API tests, WebSocket tests, memory leak simulations, and thread violations directly from the home screen, while also providing navigation to location, WebView, and secure storage test screens.

app/src/main/java/com/azikar24/wormaceptorapp/main · high confidence

The memory feature's UI components (HeapUsageCard, NativeHeapCard, MemoryChartCard, MemoryTopAppBar, and MemoryActionButtons) have been refactored to adopt the WormaCeptor design system. This update replaces hardcoded dimensions and raw color literals with semantic tokens from WormaCeptorTokens (e.g., Colors.Status, Spacing, Shapes, ComponentSize), ensuring consistent styling across the app. The diff also introduces a new ChartDimensions helper to manage chart layout calculations and updates the top app bar to use the unified WormaCeptorTopBar wrapper, improving maintainability and visual consistency.

features/memory/src/main/java/com/azikar24/wormaceptor/feature/memory/ui/components · high confidence

The Memory monitoring feature's ViewModel has been restructured to follow the Model-View-Intent (MVI) architecture. This introduces explicit state management via \MemoryViewState\ (tracking current metrics, history, and heap warnings), user actions via \MemoryViewEvent\ (start/stop monitoring, force GC, clear history), and one-time side effects via \MemoryViewEffect\. The ViewModel now consolidates data from the \MemoryMonitorEngine\ using Kotlin Flows, ensuring that monitoring state and UI updates are handled predictably and consistently.

features/memory/src/main/java/com/azikar24/wormaceptor/feature/memory/vm · high confidence

The CPU and Dependencies Inspector feature modules have been refactored to adopt the Model-View-Intent (MVI) pattern. This change introduces dedicated navigation contributors that wire up the new ViewModels via explicit factories, ensuring that the underlying monitoring engines are correctly injected. For users, this represents an internal architectural shift to a more consistent state-management approach across these features, though the visible screens and navigation paths remain functionally equivalent.

features/cpu/src/main/java/com/azikar24/wormaceptor/feature/cpu, features/dependenciesinspector/src/main/java/com/azikar24/wormaceptor/feature/dependenciesinspector · high confidence

The File Browser and Loaded Libraries features have been refactored to follow the Model-View-Intent (MVI) pattern. This change introduces dedicated navigation contributors that wire up the new ViewModels using a BaseScreen composable, ensuring consistent state handling and effect management across these modules. Users will experience the same functionality but with a more robust and standardized internal structure for state management.

features/filebrowser/src/main/java/com/azikar24/wormaceptor/feature/filebrowser, features/loadedlibraries/src/main/java/com/azikar24/wormaceptor/feature/loadedlibraries · high confidence

The Mock Rules module has been restructured to use the MVI (Model-View-Intent) pattern, introducing a new \MockRulesScreen\ for managing rules and a \MockRuleEditorScreen\ for creating and editing them. Users can now configure detailed mock rules including basic info, request matching (URL pattern, match type, HTTP method), response details (status code, message, content type, body), and configurable delays (fixed, range, or none). The feature includes navigation support via \MockRulesNavigationContributor\, localized strings for all UI elements, and baseline configurations for detekt and lint to manage code quality standards for the new implementation.

features/mockrules · high confidence

This change introduces the public API definitions (\.api\ files) and static analysis baselines for the JSON and XML syntax highlighting modules within the \infra/syntax\ layer. The API files explicitly declare that \JsonHighlighter\ and \XmlHighlighter\ implement the \SyntaxHighlighter\ contract, exposing their language identifiers and tokenization methods. Additionally, detekt baselines are added to suppress known complexity and nesting issues in the \tokenize\ implementations, while lint baselines are initialized for both modules.

infra/syntax · medium confidence

The api/common module now exposes a new public API surface (api/common.api) that includes the internal BaseServiceProviderImpl and three new notification helper classes: LeakNotificationHelper, ThreadViolationNotificationHelper, and WormaCeptorNotificationHelper. These helpers enable the app to display Android notifications for detected memory leaks, main-thread violations, and ongoing network transactions, respectively. The diff also adds detekt and lint baselines for this module to manage static analysis issues.

api/common · high confidence

The preferences screen now uses a ModalBottomSheet for editing preferences instead of a dialog, providing a different interaction model for creating and modifying settings. The interface has been updated to use the new WormaCeptorTokens design system, applying semantic colors and shapes to preference items and input fields for consistent styling across the app.

features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/ui/components · high confidence

The Preferences module has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state management system via \PreferencesViewState\ and \PreferenceEditorState\, alongside explicit event contracts (\PreferencesViewEvent\) and side-effect handling (\PreferencesViewEffect\). The \PreferencesViewModel\ now processes user interactions through these typed events, managing complex editor logic for various preference types (String, Int, Long, Float, Boolean, StringSet) and navigation flows, replacing the previous implementation with a more predictable, unidirectional data flow.

features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/vm · high confidence

The Preferences feature now uses a dedicated navigation graph that scopes the PreferencesViewModel to the entire feature, ensuring the ViewModel is shared across the PreferencesList and PreferenceDetail screens. This change implements the MVI pattern by wiring the ViewModel through a factory that provides the repository and navigator, and updates the UI destinations to consume state and events via BaseScreen, replacing previous navigation and state management approaches.

features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/navigation · high confidence

The Push Simulator screen has been reorganized into distinct UI sections: a scrollable TemplatesRow for managing saved notification templates, a NotificationFormCard for composing push notifications with character counters and channel/priority selectors, a NotificationPreview section that visualizes the notification with priority indicators and action chips, and an ActionButtonsRow for sending or saving. The main screen now handles permission checks for Android 13+ and displays snackbar feedback for send, save, delete, and load events, while a SaveTemplateDialog allows naming new templates.

features/pushsimulator/src/main/java/com/azikar24/wormaceptor/feature/pushsimulator/ui · high confidence

The Push Simulator feature now uses a Model-View-Intent (MVI) architecture, introducing explicit sealed classes for UI state (PushSimulatorViewState), user events (PushSimulatorViewEvent), and one-time side effects (PushSimulatorViewEffect). This change standardizes how the simulator handles form updates, template management (save, load, delete), and notification sending, ensuring a unidirectional data flow for more predictable behavior.

features/pushsimulator/src/main/java/com/azikar24/wormaceptor/feature/pushsimulator/vm · high confidence

The Rate Limiting feature's view model has been refactored to follow the Model-View-Intent (MVI) pattern, introducing explicit contracts for user events (such as toggling limits, selecting presets, and adjusting speed/latency), view state (including formatted speeds and stats), and one-time side effects. This change consolidates configuration and statistics from the underlying engine into a single state object, ensuring that rate-limiting settings and usage statistics are persisted and correctly restored when navigating away from and back to the screen.

features/ratelimit/src/main/java/com/azikar24/wormaceptor/feature/ratelimit/vm · high confidence

The rate limit module has been refactored to use the Model-View-Intent (MVI) pattern, introducing a new public API surface for navigation, view models, and UI state. Users interacting with the rate limiter will now see a structured set of events for managing configuration, including selecting network presets, adjusting download/upload speeds, setting latency and packet loss, and toggling the feature on or off. This change standardizes the data flow within the rate limit screen, ensuring that state changes are handled through explicit events rather than direct mutations.

features/ratelimit/api · high confidence

The rate limit module has been refactored to follow the project's standardized MVI (Model-View-Intent) pattern. This includes extracting a dedicated use case for formatting speed values (converting between Kbps and Mbps) and restructuring the navigation and view model creation via a new \RateLimitNavigationContributor\ and \RateLimitViewModelFactory\. Users will experience a more consistent internal structure for the rate limit feature, though the external behavior remains unchanged.

features/ratelimit/src/main/java/com/azikar24/wormaceptor/feature/ratelimit · medium confidence

The Recomposition feature's UI layer has been refactored to align with the app's new design system and architecture. All screens and components (including the summary screen, recomposer rows, and empty state) now use semantic tokens via \WormaCeptorTokens.semantic()\ for colors and shapes, replacing previous color scheme references. The feature also migrates to the \BaseViewModel\ MVI pattern, utilizing \WormaCeptorTopBar\ and \WormaCeptorIconButton\ wrappers for consistent navigation and actions. This ensures the Recomposition feature visually and structurally matches the rest of the application's standardized UI components.

features/recomposition/src/main/java/com/azikar24/wormaceptor/feature/recomposition/ui · high confidence

The Recomposition feature's ViewModel layer has been refactored to follow the BaseViewModel MVI pattern. This introduces a structured event-state-effect flow: user actions like resetting data or navigating back are handled via RecompositionViewEvent, triggering state updates in RecompositionViewState or side-effects like navigation via RecompositionEffect. The ViewModel now polls a RecompositionTracker every 500ms to update the dashboard with session duration, total recompositions, and the top 20 recomposers, using a FormatRecompositionSummaryUseCase for display formatting.

features/recomposition/src/main/java/com/azikar24/wormaceptor/feature/recomposition/vm · high confidence

The Dependencies Inspector feature now uses a redesigned interface built on shared WormaCeptor UI components. The main list displays dependencies in styled cards showing the name, package, detected version, and a color-coded category badge. A new summary section at the top provides quick counts for total, versioned, and unknown dependencies. Users can now filter the list by dependency category using a scrollable chip row and toggle a switch to show only versioned dependencies. The detail view has been restructured to use shared header and section components, presenting dependency metadata, detection method, and website links in a consistent layout.

features/dependenciesinspector/src/main/java/com/azikar24/wormaceptor/feature/dependenciesinspector/ui/components · high confidence

The Loaded Libraries feature now uses a refreshed UI built from new internal components: FilterSection (with scrollable type chips and a system-lib toggle), LibraryCard (displaying library name, path, size, and status badge), LibraryDetailContent (showing detailed metadata like load address and version), and SummarySection (providing counts for native, DEX, JAR, and total libraries). These components replace the previous implementation to provide a more structured and visually consistent experience for browsing and inspecting loaded libraries.

features/loadedlibraries/src/main/java/com/azikar24/wormaceptor/feature/loadedlibraries/ui/components · high confidence

The Push Token feature screen has been rebuilt using the app's new design system, replacing raw dimension literals with semantic tokens for spacing, colors, and shapes. The current token view now uses an outlined card style with dedicated components for displaying the token value, provider status, and action buttons (copy/delete), while the history section displays token lifecycle events (created, refreshed, invalidated, deleted) with color-coded icons. The top app bar has been standardized to use the shared WormaCeptorTopBar component, and the entire interface now supports the application's semantic color scheme and consistent touch targets.

features/pushtoken/src/main/java/com/azikar24/wormaceptor/feature/pushtoken/ui · high confidence

The legacy \App\ and \MainActivity\ classes have been removed from the application package. This deletion eliminates the previous Application initialization logic (including StrictMode configuration and Room database wiring) and the main Activity that handled HTTP sample requests via Retrofit and UI binding, indicating a structural shift away from the prior Android Views-based architecture.

app/src/main/java/com/azikar24/wormaceptor · high confidence

The Secure Storage module has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state management approach where user interactions are handled as explicit events (such as selecting a storage type, updating search queries, or refreshing data), which drive updates to a centralized view state. Side effects are now emitted separately from the UI state, ensuring a unidirectional data flow for managing secure storage entries, summaries, and loading indicators.

features/securestorage/src/main/java/com/azikar24/wormaceptor/feature/securestorage/vm · high confidence

The navigation and ViewModel initialization logic for the FPS, Location, Logs, Memory, Push Simulator, Push Token, Secure Storage, Thread Violation, and WebView Monitor features has been refactored to use a consistent pattern. Each feature now exposes a dedicated \FeatureNavigationContributor\ (registered via \@AutoService\) that handles route registration and screen composition, while separate \\*ViewModelFactory\ classes explicitly inject core engines and repositories. This change ensures that screens like the Location monitor (which now handles lifecycle-based real location updates) and the WebView Monitor (which manages an internal list/detail navigation graph) are wired uniformly, improving maintainability and consistency across the app's feature modules.

(repo-wide) · high confidence

The database, preferences, and websocket feature modules now use a standardized architecture where each module provides a \FeatureNavigationContributor\ (annotated with \@AutoService\) to register its specific navigation graph with the main host, and a dedicated \ViewModelFactory\ to instantiate its view model with the required dependencies (such as repositories, engines, or navigators). This change ensures consistent initialization and navigation wiring across these features without requiring manual registration in the app's core.

features/database/src/main/java/com/azikar24/wormaceptor/feature/database, features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences, features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket · high confidence

The Thread Violation module has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state management approach where user interactions (such as selecting violation types, toggling monitoring, or clearing violations) are handled as explicit events, and the UI state is derived from a single source of truth. This change improves code maintainability and predictability for the Thread Violation feature without altering its external behavior.

features/threadviolation/src/main/java/com/azikar24/wormaceptor/feature/threadviolation/vm · high confidence

The public API declarations for the domain entities module have been refreshed to reflect the current state of the codebase. This update includes the definitions for core data models such as AppDetails, CpuInfo, and Crash, as well as the complete set of cryptographic enums and configuration classes (CipherMode, CryptoAlgorithm, CryptoConfig, CryptoPreset, and CryptoResult). These changes ensure that the stable API contract accurately represents the available types and their signatures for consumers of the domain layer.

domain/entities/api · high confidence

The WebSocket Monitoring feature has been refactored to follow the Model-View-Intent (MVI) pattern. This change introduces a structured ViewModel layer that manages connection and message state, handles user interactions such as search queries, direction filtering, and message expansion, and exposes one-time side effects for the UI. Users benefit from a more robust and predictable data flow within the WebSocket monitoring interface, ensuring that connection lists and message details are filtered and displayed consistently based on user input.

features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket/vm · high confidence

The WebSocket feature module now uses a dedicated navigation graph that consolidates connection listing and message viewing into a unified route structure. This change introduces a graph-scoped ViewModel to manage state across the WebSocket sub-screens, ensuring consistent data handling as users navigate between the list of connections and individual message details. The navigation logic is now encapsulated within the feature module, improving modularity and aligning with the application's broader move toward the MVI architecture.

features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket/navigation · high confidence

The WebView Monitor feature has been refactored to follow the Model-View-Intent (MVI) pattern, introducing a structured ViewModel that manages state through immutable snapshots (WebViewMonitorViewState) and handles user interactions via a sealed class of events (WebViewMonitorViewEvent). This change enables explicit handling of user actions such as searching, filtering by resource type, and selecting requests, while emitting one-time side effects (WebViewMonitorViewEffect) like navigation to detail views, resulting in more predictable state management and clearer separation of concerns within the feature module.

features/webviewmonitor/src/main/java/com/azikar24/wormaceptor/feature/webviewmonitor/vm · high confidence

The public API for the WebView Monitor feature module has been established, exposing the navigation contributor, view model factory, and UI components. Users interacting with this module will now see a structured state management layer including view states for request lists, filtering, and selection, along with specific events for clearing filters, requests, and selections, as well as toggling resource type filters and navigating to details.

features/webviewmonitor/api · high confidence

Added architecture test for domain layer isolation; Added unit tests for API client core components; Added unit tests for CpuViewModel; Added unit tests for Crypto, Push Simulator, and Push Token ViewModels; Added unit tests for File Browser and Location features; Added unit tests for WebSocketViewModel; Added unit tests for database repository and view model; Added unit tests for feature module ViewModels; Added unit tests for the Dependencies Inspector ViewModel; Added unit tests for the Logs feature's query logic and ViewModel; Added unit tests for the Preferences feature; Added unit tests for viewer feature components.

The Gradle wrapper has been updated from version 7.4 to 8.11.1, ensuring that builds use the newer distribution for improved performance and compatibility.

gradle · high confidence

The project build system has been restructured to use a Gradle Version Catalog (defined in gradle/libs.versions.toml) for centralized dependency and plugin management. This change introduces a modular architecture with new subprojects for the API client, common utilities, domain contracts, and various feature modules (such as CPU, crypto, database, and file browser), each with its own build configuration and publishing properties. Key dependency updates include upgrading to Android Gradle Plugin 8.5.2, Kotlin 2.0.21, and Compose BOM 2024.10.01, while also adding support for Ktor, SQLCipher, and Firebase Messaging.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 51.

• Code Health 91
• Architecture 96
• Maturity 67
• Readiness 34
• Security 58
• Domain Modelling 70

• 300 commits — 239 feature/other, 61 fixes

• features/viewer — 72 commits
• (root) — 31 commits
• app/src — 26 commits
• core/engine — 20 commits
• core/ui — 19 commits
• (repo) — 18 commits
• features/database — 9 commits
• features/pushsimulator — 8 commits
• api/client — 7 commits
• infra/parser — 7 commits
• domain/entities — 6 commits
• features/location — 6 commits
• features/preferences — 6 commits
• features/crypto — 4 commits
• features/webviewmonitor — 4 commits
• api/impl — 3 commits
• features/dependenciesinspector — 3 commits
• features/filebrowser — 3 commits
• features/fps — 3 commits
• features/logs — 3 commits

• fix: chore: add GitHub issue templates for bugs and feature requests
• fix: chore: fix detekt violations and code style issues
• fix: chore: remove obsolete bugfix doc and update test Java version
• fix: fix(build): revert jitpack.yml -x flag for removed task
• fix: fix(ci): pass NVD_API_KEY env var to dependency-check plugin
• fix: fix(ci): remove SARIF upload from detekt job
• fix: fix(ci): unblock Android Lint + Dependency Analysis on pinned AGP
• fix: fix(demo): fix SegmentedControl compilation issues
• fix: fix(demo): improve bottom sheet to screen navigation transitions
• fix: fix(demo): make Launch Inspector and Test Tools buttons same width
• fix: fix(proguard): add Firebase keep rules for reflection
• fix: fix(publishing): replace en-dash with ASCII hyphen in POM_DESCRIPTION
• fix: fix(ratelimit): persist state across navigation and enable rate limiting
• fix: fix(ui): add dismiss zone and refactor overlay/HomeScreen
• fix: fix(ui): add search toggle and align icon in PreferencesListScreen
• fix: fix(ui): add top spacing to ToolsTab search bar
• fix: fix(ui): align scrollable-row contentPadding with parent padding
• fix: fix(ui): improve TransactionDetailScreen design consistency
• fix: fix(ui): improve filter bottom sheet search field and container styling
• fix: fix(ui): improve rate limit UX and make overlay toggle fully clickable
• …and 280 more

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

azikar24/WormaCeptor 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.