azikar24/WormaCeptor
62.1
Adequate · 9 November 2026
87.9k
lines of production code
Kotlin
primary language
5
measurements over time
What this system is
Features
Add Firebase Cloud Messaging support for push notifications
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
Add Firebase configuration and app assets
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
Add MainViewModel with diagnostic and stress-test capabilities
The app now includes a MainViewModel that implements the MVI pattern to manage the main screen's state and user interactions. This component exposes a suite of diagnostic and stress-test tools, allowing users to trigger API and WebSocket tests, seed local data stores, simulate CPU/memory/frame-drop stress, and navigate to specific feature screens like Location, WebView, and Secure Storage.
app/src/main/java/com/azikar24/wormaceptorapp/main/viewmodel · high confidence
Add PDF document parsing and metadata extraction
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
Add Protobuf body parser with schema-less wire format decoding
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
Add Secure Storage test screen for encrypted preferences and KeyStore
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
Add device info screen navigation with MVI integration
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
Add floating network inspector button service
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
Add navigation route constants for test tools
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
Add no-op implementation for the service provider interface
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
Add short labels for dependency categories in the inspector
A new utility function \shortLabel()\ has been added to the dependencies inspector UI layer, mapping each \DependencyCategory\ (such as NETWORKING, DI, UI\_FRAMEWORK, etc.) to a concise two-letter abbreviation (e.g., "Net", "DI", "UI"). This enables the UI to display compact category identifiers in the dependencies inspector tool screen.
features/dependenciesinspector/src/main/java/com/azikar24/wormaceptor/feature/dependenciesinspector/ui/util · high confidence
Added SQLite persistence entities for crash, leak, location, mock, and network data
The SQLite persistence layer now includes Room entity definitions for storing application diagnostics and simulation data. This adds database schemas for capturing crash reports (CrashEntity), memory leak details (LeakEntity), mock location presets and active states (LocationPresetEntity, MockLocationEntity), mock network rules with complex delay/behavior serialization (MockRuleEntity), push notification templates (PushTemplateEntity), intercepted WebView requests (WebViewRequestEntity), and general network transactions with optimized indexing (TransactionEntity). These entities enable the app to persist and retrieve this data locally using SQLite via Room.
sqlite · high confidence
Added debug-only recomposition tracking dashboard
A new debug feature module has been added to track Jetpack Compose recomposition counts in real-time. This includes a thread-safe singleton (\RecompositionTracker\) that records events and calculates rates, along with the necessary ViewModel state and effect classes to display a dashboard of the top recomposing composables. This functionality is isolated to debug builds and no-ops in release, allowing developers to identify performance bottlenecks without impacting production app size or behavior.
recomposition · high confidence
Added domain entities for mock HTTP rule configuration
Introduced new domain models to support a mock HTTP server feature. MockRule defines the structure for intercepting requests with matchers, priorities, and behaviors, while MockResponse specifies the details of the simulated HTTP response (status, headers, body). UrlMatchType provides the strategies (exact, prefix, regex) for matching request URLs against these rules.
domain/entities/src/main/java/com/azikar24/wormaceptor/domain/entities/mock · high confidence
Added file appearance resolution and syntax highlighting utilities for the file browser
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
Enforce code quality and commit standards via new linting infrastructure
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
File browser data layer implementation
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
Initial wiring module scaffolding
A new 'wiring' module has been added to the project, providing the foundational structure for this component. This includes an empty public API surface (wiring.api), a lint baseline configuration to suppress known obsolete lint registry warnings from Compose and Lifecycle dependencies, and a minimal AndroidManifest file.
wiring · high confidence
Introduce Android Studio plugin for WormaCeptor network inspection
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
Introduce Database Browser screens with unified UI components
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
Introduce Dependencies Inspector screen with search, filtering, and detail views
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
Introduce Favorites management and redesigned crash reporting UI
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
Introduce File Browser feature with comprehensive file viewing and management
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
Introduce Logs Console screen with capture controls and filtering
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
Introduce MCP bridge with device diagnostics, network inspection, and mock tools
The bridge component now provides a set of Model Context Protocol (MCP) tools for interacting with an Android device. It includes diagnostic capabilities to list and view crashes, memory leaks, and thread violations, as well as to retrieve app logs via ADB. Network debugging is supported through tools to list, view, and replay HTTP transactions and WebSocket connections. The bridge also enables performance monitoring for CPU, memory, and FPS, along with the ability to simulate GPS locations and create mock rules to intercept and modify network requests for testing purposes.
bridge · high confidence
Introduce MCP device server with monitoring, replay, and timeline capabilities
The device-server now exposes an MCP-compatible API (default port 8999) that allows external clients to control and inspect the app. Users can start or stop CPU, memory, and FPS monitoring via the new monitoring routes, while the performance overlay continues to display metrics independently. Network transactions can be exported as cURL commands or replayed against the real server (bypassing mock rules and throttling), and a unified timeline endpoint aggregates transactions, crashes, logs, thread violations, leaks, and WebSocket messages into a single chronological view. Additionally, wait endpoints let clients block until a new transaction or crash occurs, and mock rules can be created or derived from existing transactions. The server supports optional authentication, configurable body size limits, and automatically redacts secret-looking values in responses.
device-server · high confidence
Introduce MCP device server, bridge, and npx launcher
This change adds the core components for the MCP integration: a new device server (with API definitions and lint/detekt baselines), a bridge component (with its own detekt baseline), and an npx launcher script that downloads, verifies, and runs the bridge JAR. The bridge facilitates communication between the MCP client and the device server, while the device server exposes the necessary endpoints for device interaction.
mcp · high confidence
Introduce Mock Rules feature with MVI architecture and rule editor
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
Introduce Secure Storage feature with modern UI components
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
Introduce Thread Violation monitoring screen
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
Introduce WebSocket Monitor feature for real-time connection inspection
The new WebSocket Monitor feature provides a dedicated UI for inspecting active WebSocket connections and their message traffic. Users can view a list of connections, search by URL, and drill down into individual connections to view, search, and expand message details. The interface includes direction filters (Sent/Received) and confirmation dialogs to clear messages or all connections, with all user-facing text localized via string resources.
features/websocket · high confidence
Introduce WebSocket monitoring feature with connection and message inspection
Users can now monitor WebSocket connections and inspect their messages via a new feature module. The UI includes a list of active connections with search and filtering capabilities, and a detail screen for viewing individual message payloads, direction, and size. The implementation follows the MVI pattern, using a dedicated ViewModel and navigation contributor to integrate the new screens into the app's main navigation graph.
features/websocket/src/main/java/com/azikar24/wormaceptor/feature/websocket · high confidence
Introduce WebView Monitor feature with request inspection and filtering
The WebView Monitor feature is now available, allowing users to view, search, and filter web requests captured from the app's WebViews. The list screen displays request statistics, supports filtering by resource type (e.g., XHR, Stylesheet, Image), and includes a search bar to filter by URL, method, or host. Tapping a request opens a detail screen showing the full URL, headers, response status, duration, and any error messages. The feature uses an MVI architecture with a dedicated ViewModel and navigation contributor to integrate into the app's main navigation graph.
features/webviewmonitor/src/main/java/com/azikar24/wormaceptor/feature/webviewmonitor · high confidence
Introduce WormaCeptor Android client API with Ktor support and data redaction
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
Introduce WormaCeptor MCP Bridge for Android device debugging
The new mcp/bridge component acts as a bridge between an MCP client and the WormaCeptor device server on an Android device. It handles ADB device discovery and port forwarding, manages the connection lifecycle (including reconnection and handling frozen apps), and exposes a suite of diagnostic and action tools via the MCP protocol. These tools cover network traffic inspection, crash and log analysis, performance monitoring, storage browsing, and app control (like bringing the app to the front). The bridge also includes logic to locate the ADB executable across different OS environments and parses logcat output for readability.
mcp/bridge · high confidence
Introduce common presentation layer with BaseViewModel and BaseScreen
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
Introduce dedicated UI components for the Thread Violation feature
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
Introduce dedicated viewer module with edge-to-edge support and deep linking
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
Introduce embedded MCP device server with diagnostic and action APIs
The mcp/device-server module now provides an embedded Ktor HTTP server that exposes a comprehensive set of REST and WebSocket endpoints for debugging and device control. Users can access crash reports, memory leaks, thread violations, and device information via diagnostic routes, while action routes allow clearing transactions/logs, simulating locations, and pushing notifications. The server includes built-in security via local-request guarding and optional Bearer token authentication, and it auto-starts on device boot to provide immediate access to these capabilities.
mcp/device-server · high confidence
Introduce new Welcome screen and Test Tools sheet components
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
Introduce public API for the Recomposition feature module
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
Introduce recomposition feature with summary screen and rate-limiting logic
This change adds the initial implementation of the recomposition feature module. It introduces a new navigation route that displays a summary screen, wired via a DI-contributed navigation contributor. The feature includes a new use case for formatting duration and count values for the UI, and a new internal utility class for calculating event rates using a sliding window algorithm, which likely supports the feature's core logic or monitoring.
features/recomposition/src/main/java/com/azikar24/wormaceptor/feature/recomposition · high confidence
Introduce transaction data models for Android Studio plugin
The Android Studio plugin now includes structured data models to represent network transactions. A new \TransactionData.kt\ file defines \TransactionStatus\ and \TransactionSummary\, providing optimized fields for displaying transaction details (such as method, host, path, status code, and duration) in the IDE's list view. It also introduces \TransactionDetail\ to hold full request and response bodies, headers, and metadata, enabling the plugin to capture and display comprehensive transaction information within the IDE interface.
android-studio · high confidence
Introduces core engine modules for network capture, querying, and device simulation
This change adds the foundational engine components for the WormaCeptor platform. It introduces CaptureEngine and QueryEngine to handle the recording, storage, and retrieval of network transactions, including body blob management and crash reporting via CrashReporter. Device simulation capabilities are added through LocationSimulatorEngine for mock GPS/network locations and PushSimulatorEngine for generating simulated notifications. Additionally, it provides infrastructure for content parsing and display via DefaultParserRegistry and DefaultHighlighterRegistry, along with configuration and state management through CoreHolder and McpHolder.
core/engine/src/main · high confidence
Introduces deep link navigation and new viewer components for JSON, PDF, and crash data
The viewer now supports opening specific screens via deep links (e.g., wormaceptor://tools/memory) through a new DeepLinkHandler, and adds a collapsible, syntax-highlighted JsonTreeView component for inspecting JSON payloads. It also introduces a dedicated PDF viewer with page rendering, thumbnail caching, and navigation controls, alongside new ViewModel contracts and state models for crash lists and transaction details to support these viewing capabilities.
viewer · high confidence
Introduces domain contracts for parser, extension, and filtering architecture
This change establishes the core domain interfaces and data structures that define how the application handles content parsing, custom metadata extensions, syntax highlighting, and transaction filtering. It adds the BodyParser interface and BaseBodyParser abstract class to standardize content-type detection and formatting, defines the ExtensionProvider interface and ExtensionContext for extracting custom metadata from network transactions, introduces the SyntaxHighlighter contract and Token/TokenType types for code tokenization, and provides the TransactionFilters data class for querying requests by status, method, duration, and content type.
contracts · high confidence
Introduces domain entities for cryptographic configuration and HAR export
This change adds new domain models to the application's core layer, enabling users to configure encryption settings and export network traffic data. The new CryptoConfig entity allows specifying algorithms (AES, DES, RSA), cipher modes (CBC, GCM, etc.), and key formats, with built-in validation for key lengths and required initialization vectors. Additionally, HarEntry, HarRequest, and HarResponse entities are introduced to support exporting captured HTTP transactions in the standard HAR 1.2 format, including support for custom extensions like WebSocket frames and TLS details. These entities form the data foundation for the upcoming export and cryptographic features.
domain/entities/src/main/java/com/azikar24/wormaceptor/domain/entities · high confidence
Introduction of feature-specific navigation interfaces
New navigation contracts have been added for the Database and Preferences features. The DatabaseNavigator interface defines navigation actions for tables, table data, queries, and back navigation, while the PreferencesNavigator interface handles navigation to details and back. These interfaces standardize how these specific feature modules handle navigation flows within the application.
features/database/src/main/java/com/azikar24/wormaceptor/feature/database/navigator, features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences/navigator · high confidence
Mock Rules editor now pre-fills from captured transactions
The Mock Rules feature now allows users to create a new rule draft automatically populated with the details of a captured network transaction. When initiating a new rule from a transaction, the editor pre-fills the name, URL pattern, HTTP method, status code, headers, and response body. To ensure usability, the system intelligently handles large or binary response bodies by omitting them from the draft and displaying a notice to the user, preventing performance issues or data corruption while allowing the user to manually paste content if needed.
mockrules · high confidence
Mock Rules feature API surface and state model introduced
The Mock Rules feature now exposes its public API contract, defining the navigation contribution for the feature module and establishing the core state management model. This includes the \MockRulesScreen\ composable entry point, a comprehensive \EditorState\ data class for managing rule configuration (such as URL patterns, methods, status codes, and delay types), and an MVI-style event/effect system (\MockRulesViewEvent\, \MockRulesEffect\) to handle user interactions like saving or navigating back. This change formalizes the interface between the UI layer and the rest of the application for the Mock Rules functionality.
features/mockrules/api · high confidence
New CPU monitoring screen with usage gauges, per-core bars, and history charts
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
New Device Information feature with MVI architecture
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
New FPS monitoring screen with real-time performance visualization
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
New HTML and Multipart body parsers added
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
New Loaded Libraries screen with search, filtering, and detail view
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
New Memory Monitoring Screen with Edge-to-Edge Layout
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
New Rate Limit UI components with semantic theming
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
New Rate Limit configuration screen with MVI architecture
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
New UI utility functions for clipboard, formatting, and accessibility
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
New build-logic convention plugins for Android, Compose, and Maven publishing
This change introduces a set of new Gradle convention plugins in the build-logic module to standardize module configuration and enable library distribution. It adds plugins for pure JVM libraries, Android libraries, and Android libraries with Jetpack Compose (pinning the Compose BOM to 2024.10.01 and including Material 3). It also introduces a feature module plugin that bundles Compose with Koin, lifecycle components, and KSP-based AutoService. Additionally, a publishing plugin is added to configure Maven Central deployment for 47 modules, handling signing, POM metadata (MIT license), and a workaround for AGP 8.6.0's Dokka compatibility issues by attaching empty Javadoc JARs.
build-logic · high confidence
New common presentation module with BaseViewModel and BaseScreen
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
New crash and network transaction export capabilities
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
New data layer for reading and writing app SharedPreferences
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
New database browsing capability via read-only SQLite data source
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
New domain contracts and tooling baselines for WormaCeptor
This change introduces the core domain contracts for the WormaCeptor debugging tool, defining the interfaces for data access and content processing. It adds repository contracts for managing network transactions, crashes, memory leaks, SQLite databases, file systems, and shared preferences, alongside contracts for parsing and formatting various content types (JSON, XML, Protobuf, multipart, images). A FeatureConfig contract is also included to allow runtime toggling of these tools. Additionally, detekt and lint baseline files are added to configure code quality checks for the new module.
domain/contracts · high confidence
New domain entities for diagnostics and inspection tools
The domain layer now includes a comprehensive set of data models to support new debugging and inspection capabilities. These include entities for capturing device and application context (DeviceInfo, CpuInfo, MemoryInfo, FpsInfo), monitoring network activity (NetworkTransaction, Request, Response), and inspecting file systems and databases (FileEntry, FileInfo, ColumnInfo, DatabaseInfo). Additional models support memory leak detection (LeakInfo), cryptographic operations (CryptoResult), dependency analysis (DependencyInfo), and log viewing (LogEntry). Configuration for the debug server is also defined via McpConfig, which includes a new redactSecrets option to mask sensitive values in logs and preferences.
entities · high confidence
New glitch visual effect with shader-based implementation
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
New image and PDF preview components with fullscreen viewer
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
New image format detection and metadata extraction
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
New location map card and map view components
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
New location simulation ViewModel with MVI architecture
The location feature now uses a new LocationViewModel based on the MVI pattern (extending BaseViewModel) to manage mock location state, presets, and coordinate input. This change introduces reactive flows for real device location tracking, current mock location, and preset filtering, along with event handlers for setting mock locations from input, presets, or the current real location, and managing preset persistence.
features/location/src/main/java/com/azikar24/wormaceptor/feature/location/vm · high confidence
New log filtering and display components
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
New performance and dependency inspection engines
The engine module introduces several new capabilities for real-time application analysis. A CPU monitor engine now tracks system-wide and per-core usage, frequency, and temperature with automatic fallback to process-level metrics on restricted devices. An FPS monitor engine measures frame delivery times to calculate current, average, min, and max frame rates, while also identifying dropped frames and jank. Memory monitoring has been added to track Java and native heap usage alongside approximate garbage collection events. A new leak detection engine monitors Activity and Fragment lifecycles to identify retained objects that should have been garbage collected. Additionally, a dependencies inspector engine dynamically scans the application's classpath to detect third-party libraries, and a loaded libraries engine inspects native libraries and DEX/JAR files from the APK and process maps. Log capture functionality has also been added to record and filter logcat output for the current process.
engine · high confidence
New public API for the Device Info feature
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
New structured viewers for request body content types
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
New test screens for location, secure storage, and web view inspection
The app now includes dedicated test screens for inspecting location services, secure storage, and web views. These new UI components allow users to request location permissions and mock locations, manage and view encrypted preferences and KeyStore entries, and load URLs in a web view for testing. These screens are part of the broader set of sample services and stress tools designed to exercise the app's inspectors.
app/src · high confidence
New test screens for location, secure storage, and webview capabilities
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
New viewer utilities for sharing, cURL generation, and image handling
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
Preferences feature navigation and ViewModel wiring established
The Preferences module now registers its navigation routes (Preferences and DataStore graphs) with the main application NavHost via an auto-service contributor, and includes a dedicated ViewModel factory to instantiate the PreferencesViewModel with the required repository and navigator dependencies.
features/preferences/src/main/java/com/azikar24/wormaceptor/feature/preferences · high confidence
Preferences feature now includes dedicated detail and list screens with search and design system integration
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
Preferences inspector now supports reading Preferences DataStore files
The Preferences feature has been expanded to include a read-only inspector for AndroidX DataStore files. Users can now navigate to a dedicated DataStore graph in addition to the existing SharedPreferences inspector. This new capability allows viewing and searching DataStore preference items (stored as \.preferences\_pb\ files) without the ability to edit or delete them, ensuring data integrity while providing visibility into this storage mechanism.
preferences · high confidence
Public API surface for the Dependencies Inspector feature is established
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
Public API surface for the Memory feature module
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
Push Token feature API surface exposed
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
Push Token management screen UI state and events defined
The Push Token management feature now exposes its user-facing contract through dedicated ViewModel types. Users can now trigger actions such as fetching, refreshing, deleting, or copying the push token, as well as clearing history and dismissing errors. The UI state model tracks the current token, a history of past tokens, loading status, and any error messages, while one-time side effects (like copying to clipboard) are handled separately to ensure clean UI updates.
pushtoken · high confidence
Redesigned location management interface with presets and map visualization
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
Repository initialization with v3.4.0 release artifacts and tooling
The repository has been initialized with the v3.4.0 release, including the full changelog, MIT license, and comprehensive documentation (README, contributing guide, MCP setup). The project now ships with a standardized development environment via \.editorconfig\, pre-commit hooks (\.lefthook.yml\), secret scanning (\.gitleaks.toml\), and lint rules (\lint.xml\). Build and release automation is configured through \release-please-config.json\, \jitpack.yml\, and CI pipelines, while the Gradle wrapper has been updated to v8.5.
(repo-wide) · high confidence
SQLite persistence layer and in-memory debug repositories for WormaCeptor
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
Sample service adds body redaction and expanded content-type testing
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
Secure Storage feature API surface published
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
Syntax highlighting support for JSON and XML
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
WebView Monitor feature module initialization
The WebView Monitor feature module has been added to the application, providing a dedicated UI for monitoring and inspecting WebView network requests. This includes a list view with search and filter capabilities (by resource type), a detail screen for individual request inspection (showing headers, status, and timing), and the underlying MVI-based ViewModel architecture to manage state and navigation.
features/webviewmonitor · high confidence
Removals
Removal of in-memory HTTP transaction storage implementation
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
Removal of legacy no-op and Room-based persistence modules
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
Removal of sample data generation class
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
WormaCeptor library module removed
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
API
Exposed Loaded Libraries feature API surface
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
Introduce public API surface for the CPU monitoring feature
The CPU feature now exposes a stable public API contract, defining the navigation contributor, ViewModel factory, and UI composables for the CPU screen. This includes the CpuViewModel and its associated state (CpuViewState) and events (StartMonitoring, StopMonitoring, ClearHistory), enabling external modules to integrate with the CPU monitoring capabilities and view model lifecycle.
features/cpu/api · high confidence
Leak Detection feature exposes public API surface
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
Location feature API surface and MVI state model exposed
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
Logs feature API surface published
The public API for the Logs feature has been generated, exposing the navigation contributor, ViewModel factory, and UI composable. Users and other modules can now interact with the Logs screen via the \LogsScreen\ composable, which accepts a \LogsViewModel\ and modifier. The ViewModel exposes state for log capture status, auto-scroll, search query, selected log levels, and the log list itself, while handling events for toggling auto-scroll, changing search queries, selecting log levels, and clearing logs or filters.
features/logs/api · high confidence
New API surface dump for the viewer feature module
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
New API surface for HTTP/WebSocket interception and feature management
The public API contract for the client library has been updated to expose new capabilities for intercepting network traffic and managing application features. Host applications can now configure redaction rules for HTTP request/response bodies, headers, and JSON/XML values via the new \RedactionConfig\ class and the \WormaCeptorInterceptor\. Additionally, WebSocket activity is now monitored through \WormaCeptorWebSocket\, and WebView traffic can be intercepted using \WormaCeptorWebView\. The API also introduces a \Feature\ enum to enable or disable specific debugging tools (such as CPU/Memory monitors, database browsers, and log consoles) and provides methods in \WormaCeptorApi\ to query enabled features, register extension providers, and control the floating debug button and performance overlay.
api/client/api · high confidence
New public API surface for core engine modules
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
New public API surface for the Crypto feature module
The \features/crypto/api\ module now exposes a new public API file (\crypto.api\) that defines the public contract for the crypto feature. This includes the \CryptoNavigationContributor\ for integrating the feature into the app's navigation graph, the \CryptoViewModelFactory\ for creating view models, and the public UI composable singleton classes (such as \CryptoScreen\, \CryptoResultCard\, and \HistoryItem\) along with the view model effect and event types (\CryptoViewEffect\, \CryptoViewEvent\). This change establishes the external interface for the crypto functionality, allowing other modules or tests to depend on these specific classes and methods.
features/crypto/api · high confidence
Preferences feature API surface stabilized
The public API for the Preferences feature module has been formally defined and stabilized in \preferences.api\. This change exposes the navigation contributor, ViewModel factory, and data layer implementations (including both DataStore and legacy SharedPreferences repositories) as part of the stable contract. It also publishes the UI composables for the preferences list and detail screens, along with supporting components like the edit sheet and item card, ensuring that external consumers or internal modules can rely on these specific interfaces for navigation, state management, and rendering without breaking changes.
features/preferences/api · high confidence
Published domain contract API surface
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
Published domain entity API surface
The public API surface for domain entities has been published in \domain/entities/api/entities.api\, exposing the stable contracts for classes such as \AppDetails\, \CipherMode\, \ColumnInfo\, \CpuInfo\, \Crash\, \CryptoAlgorithm\, \CryptoConfig\, \CryptoOperation\, \CryptoPreset\, and \CryptoResult\. This defines the external interface for these domain models, allowing host applications and other modules to depend on these specific types and their members without relying on internal implementation details.
domain/entities/api · high confidence
Published public API surface for core UI components
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
Push Simulator API surface exposes MVI-based navigation and state management
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
Thread Violation feature API surface published
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
Architecture
Stabilized public API surfaces and code-quality baselines for infrastructure modules
This change introduces API declaration files (\.api\) and lint/detekt baselines for the \infra\ module's parser, persistence, and syntax-highlighting components. By publishing the public contracts for body parsers (form, HTML, image, JSON, multipart, PDF, protobuf, XML), SQLite persistence entities and DAOs, and syntax highlighters (JSON, XML), the project now enforces stable, auditable public interfaces and suppresses known static-analysis warnings. This ensures that future refactors or additions to these infrastructure areas do not accidentally break public APIs or introduce unchecked code-quality issues.
infra · high confidence
Behavioural changes
1 commit (0 fixes) modifying scripts
A change to existing behaviour in scripts — 1 commit, 1 file: “chore(dev): add scripts/device.sh for shared emulator and adb”.
scripts · medium confidence · unverified
Added API signatures and code-quality baselines for API implementation modules
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
Added ProGuard rules for navigation discovery and regenerated lint/detekt baselines
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
Adopts MVI pattern for feature UI state management
The Memory, Rate Limit, Secure Storage, and WebView Monitor features now use a Model-View-Intent (MVI) architecture. This introduces explicit sealed classes for user actions (Events) and side effects (Effects), alongside dedicated state data classes (e.g., MemoryViewState), ensuring that UI interactions are handled through a unidirectional data flow for more predictable behavior.
(repo-wide) · high confidence
Application initialization and extension registration
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
CPU monitoring ViewModel adopts MVI architecture
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
Centralized design token system for consistent theming and accessibility
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
Centralized navigation routes and modular feature graph registration
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
Crypto feature adopts MVI architecture and design system
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
Crypto feature adopts MVI architecture with explicit event and effect contracts
The crypto module now uses a Model-View-Intent (MVI) pattern, introducing structured contracts for user interactions and UI side-effects. Users will experience the same functionality (encrypt/decrypt, key generation, history management, clipboard copy) but driven by a more robust state management layer that clearly separates input events (like selecting algorithms or clearing history) from one-time UI effects (like navigating back or showing a generated key notification).
crypto · high confidence
Database encryption with in-place migration for existing users
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
Database feature API surface updated to reflect MVI architecture and new navigation structure
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
Database feature adopts MVI architecture with structured state and event handling
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
Database feature navigation restructured to use graph-scoped ViewModels
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
Dependencies Inspector ViewModel adopts MVI architecture
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
Dependencies Inspector adopts MVI state and event model
The Dependencies Inspector feature now uses a Model-View-Intent (MVI) architecture, introducing explicit \DependenciesInspectorViewState\ and \DependenciesInspectorViewEvent\ classes. This change consolidates UI state (such as filtered dependencies, search queries, and loading indicators) and user actions (like category selection and search toggling) into a structured, unidirectional flow, improving how the screen manages data and user interactions.
dependenciesinspector · high confidence
Device Info screen adopts MVI architecture with unified UI components
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
Device info UI components adopt semantic design tokens
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
Device info screen adopts MVI architecture with explicit state and effect models
The device info feature now uses a Model-View-Intent (MVI) pattern, introducing distinct sealed classes for user events (load, refresh, copy, share), UI state (loading, refreshing, error, data), and one-shot side effects (copy to clipboard, share text). This structural change standardizes how the screen handles user interactions and displays status, ensuring that actions like copying device details or sharing the report are managed through explicit, predictable state transitions rather than implicit view updates.
deviceinfo · high confidence
Device info screen now supports copying and sharing detailed device reports
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
FPS Monitor ViewModel adopts MVI architecture
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
FPS feature API surface and MVI architecture exposed
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
FPS feature UI components adopt semantic design tokens and outlined card style
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
FPS feature adopts MVI architecture with explicit state and event models
The FPS monitoring feature has been refactored to follow the Model-View-Intent (MVI) pattern. This introduces a structured state model (FpsViewState) that exposes the current FPS info, a history of FPS readings, the monitoring status, and a warning flag, alongside a sealed class of user actions (FpsViewEvent) for starting, stopping, toggling, and resetting monitoring. This change standardizes how the UI reacts to user input and displays data within the FPS module.
fps · high confidence
File browser API surface published with MVI state management
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
File browser ViewModel adopts MVI architecture with explicit event and effect types
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
File browser adopts MVI state management
The file browser feature has been refactored to use the Model-View-Intent (MVI) pattern. This introduces explicit, immutable state models (FileBrowserViewState) and distinct event types (FileBrowserViewEvent) for user interactions, along with side-effect handling (FileBrowserViewEffect). For the user, this ensures a more predictable and consistent UI behavior as state changes are now centrally managed and emitted as single sources of truth, improving reliability during navigation, file selection, and search operations.
filebrowser · high confidence
Introduce MVI ViewModels for Viewer features
The viewer module now uses dedicated MVI ViewModels to manage UI state and user interactions for the Home screen, Transaction list, Transaction pager, and Crash list. This change centralizes logic for features such as transaction search and filtering, multi-select actions, export/share capabilities, crash management, and home-screen navigation, replacing previous ad-hoc state handling with a structured reactive approach.
features/viewer/src/main/java/com/azikar24/wormaceptor/feature/viewer/vm · high confidence
Introduce centralized WormaCeptor design system and theme entry point
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
Introduce modular navigation and ViewModel factory for the Database feature
The Database feature now registers its navigation routes automatically via a new DatabaseNavigationContributor that implements the FeatureNavigationContributor interface, and it uses a dedicated DatabaseViewModelFactory to instantiate the DatabaseViewModel with its required dependencies (repository, application context, and navigator). This change standardizes how the feature integrates with the app's navigation graph and ViewModel lifecycle, ensuring consistent initialization and navigation behavior for users accessing the database module.
features/database/src/main/java/com/azikar24/wormaceptor/feature/database · high confidence
Introduce new Secure Storage UI components
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
Introduce public API surface and code-quality baselines for the Android platform module
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
Introduce unified WormaCeptor design-system components
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
Introduces MVI state and event models for CPU monitoring
The CPU monitoring feature now uses a Model-View-Intent (MVI) architecture. New files define CpuViewState to hold monitoring data (current CPU info, history, warning status) and CpuViewEvent to represent user actions (start/stop monitoring, clear history). This change standardizes the module structure and prepares the UI for the new pattern.
cpu · high confidence
Leak Detection and Thread Violation features adopt MVI state and event models
The Leak Detection and Thread Violation feature modules now use a Model-View-Intent (MVI) architecture. This introduces explicit state classes (LeakDetectionViewState, ThreadViolationViewState) to manage UI data such as filtered lists, loading indicators, and selection status, alongside sealed event classes (LeakDetectionViewEvent, ThreadViolationViewEvent) to handle user actions like severity/type filtering, item selection, and triggering checks or monitoring. This change standardizes how these features manage data flow and user interactions.
leakdetection, threadviolation · high confidence
Leak Detection screen adopts shared design system and MVI architecture
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
Leak detection UI components adopt WormaCeptor design tokens
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
Leak detection feature adopts MVI architecture
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
Leak detection feature adopts MVI architecture with modular navigation
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
Loaded Libraries feature adopts MVI architecture
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
Loaded Libraries feature adopts MVI state and event models
The Loaded Libraries module now uses a Model-View-Intent (MVI) architecture, introducing explicit state and event classes to manage the UI. Users will experience the same library browsing, filtering, and selection capabilities, but the underlying structure now explicitly tracks loading states, search queries, system library visibility, and selected library details through a centralized state object and a sealed class for user actions.
loadedlibraries · high confidence
Location and WebView test screens migrated to MVI architecture
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
Location feature adopts MVI architecture
The Location Simulation feature has been refactored to use the Model-View-Intent (MVI) pattern. This introduces a structured state management approach with distinct sealed classes for user events (LocationViewEvent), UI state (LocationViewState), and one-time side effects (LocationViewEffect), providing a clearer separation of concerns for handling inputs like coordinate changes, preset management, and mock location toggling.
location · high confidence
Logs feature adopts MVI architecture with debounced filtering
The Logs feature has been refactored to follow the Model-View-Intent (MVI) pattern, introducing a dedicated ViewModel that manages state via sealed classes for effects and events. Users benefit from improved performance and responsiveness through the integration of a debounced search query pipeline, which filters logs based on text, selected log levels, and tags. The ViewModel now explicitly handles capture lifecycle events (start/stop/clear) and exposes real-time metrics such as total log count and per-level counts, ensuring the UI remains synchronized with the underlying log capture engine.
features/logs/src/main/java/com/azikar24/wormaceptor/feature/logs/vm · high confidence
Logs feature adopts MVI architecture with structured filtering and state management
The Logs feature has been refactored to follow the Model-View-Intent (MVI) pattern, introducing a new state container (LogsViewState) and a set of user-initiated events (LogsViewEvent) to manage interactions such as search queries, log level filtering, auto-scroll toggling, and capture control. Additionally, a new LogQuery class has been added to support advanced text-based filtering, allowing users to include or exclude logs by tag, message, or both using a simple query syntax (e.g., 'tag:system', '-message:error').
logs · high confidence
Main activity adopts MVI pattern with demo tools and permission handling
The main entry point now uses the Model-View-Intent (MVI) architecture, managing state via MainViewModel and exposing effects for navigation and UI updates. It includes a bottom sheet for accessing sample services (DataStore, Database, File, Logger, Preferences, Stress) and test screens (Location, Secure Storage, WebView) for exercising inspectors. The activity also handles notification permissions on Android 13+ and integrates a glitch animation effect that can trigger a simulated crash for testing purposes.
app/src/main/java/com/azikar24/wormaceptorapp/main/view · high confidence
Memory feature UI components migrated to WormaCeptor design tokens
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
Memory monitoring ViewModel refactored to MVI pattern
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
Migrate CPU and Dependencies Inspector features to MVI architecture
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
Migrate File Browser and Loaded Libraries to MVI architecture
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
New internal notification helpers and API surface for leak, thread, and transaction alerts
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
Preferences UI adopts new design tokens and modal bottom sheet
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
Preferences feature adopts MVI architecture with new state and event contracts
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
Push Simulator UI restructured with new form, preview, and template components
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
Push Simulator ViewModel adopts MVI pattern
The Push Simulator screen now uses a new ViewModel based on the MVI (Model-View-Intent) pattern, extending BaseViewModel. This change introduces explicit state management for the simulator form, allowing users to update notification details (title, body, channel, priority), manage up to three custom actions, and persist or load notification templates. The ViewModel handles sending simulated notifications via the engine and manages UI effects such as permission dialogs and error messages.
features/pushsimulator/src/main/java/com/azikar24/wormaceptor/feature/pushsimulator/vm · high confidence
Push Simulator adopts MVI state management
The Push Simulator feature now uses a Model-View-Intent (MVI) architecture, introducing explicit sealed classes for user events (PushSimulatorViewEvent), UI state (PushSimulatorViewState), and one-time side effects (PushSimulatorViewEffect). This change structures how the simulator handles form inputs, template management, and notification sending, ensuring a predictable flow of data between the UI and the view model.
pushsimulator · high confidence
Rate Limiting screen adopts MVI architecture with state persistence
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
Rate limit feature adopts MVI architecture
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
Rate limit feature adopts standardized MVI architecture and formatting
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
Recomposition feature UI adopts semantic design tokens and MVI pattern
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
Recomposition feature adopts MVI architecture with BaseViewModel
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
Redesign Dependencies Inspector UI with new components and category filtering
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
Redesigned Loaded Libraries UI with new components
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
Redesigned push token management UI with semantic theming
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
Removal of legacy Application and Activity classes
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
Secure storage feature adopts MVI architecture
The Secure Storage feature has been refactored to use the Model-View-Intent (MVI) pattern, introducing new ViewModel, State, and Event classes to manage user interactions and data flow. This change standardizes how the feature handles filtering entries by storage type and search queries, manages loading and error states, and updates the UI based on engine data, providing a more predictable and maintainable structure for future enhancements.
securestorage · high confidence
Shared protocol DTOs and health check data structure
The CommonDtos file has been moved from the device-server module to the protocol module to enable sharing between the bridge and device server. Additionally, a new HealthDto data class is introduced to support the /api/health endpoint, including fields for server identity, version, timestamp, and the application package name used for ADB diagnostics.
repository · high confidence
Standardize feature module navigation and ViewModel wiring
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
Standardized navigation and ViewModel wiring for Location and Push Token features
The Location and Push Token feature modules now use dedicated navigation contributors and ViewModel factories to integrate with the app's navigation graph. The Location feature adds a \LocationNavigationContributor\ that registers the location screen and manages lifecycle-aware permission requests and real-location updates, supported by a \LocationViewModelFactory\ to inject dependencies. Similarly, the Push Token feature introduces a \PushTokenNavigationContributor\ to register its screen and a \PushTokenViewModelFactory\ for dependency injection, enabling the screen to fetch and copy the push token via the system clipboard with a temporary snackbar confirmation.
features/location/src/main/java/com/azikar24/wormaceptor/feature/location, features/pushtoken/src/main/java/com/azikar24/wormaceptor/feature/pushtoken · high confidence
Thread Violation feature adopts MVI architecture
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
WebSocket feature adopts MVI state and event model
The WebSocket feature module now uses a Model-View-Intent (MVI) architecture, introducing explicit state and event classes to manage user interactions. WebSocketViewState now tracks connection and message data using immutable collections, including live message counts per connection and direction-specific counts, while also managing UI states like loading indicators and confirmation dialogs for clearing data. WebSocketViewEvent defines specific user actions such as changing search queries, selecting or clearing connections, filtering messages by direction, expanding messages, and requesting confirmation to clear all or specific messages.
database, websocket · high confidence
Test coverage
Added architecture test for domain layer isolation; Added comprehensive unit tests for core engine modules; Added comprehensive unit tests for the viewer feature; Added unit tests for API client components; Added unit tests for CpuViewModel; Added unit tests for Crypto, Push Simulator, and Push Token ViewModels; Added unit tests for File Browser data and view models; Added unit tests for Loaded Libraries and WebView Monitor view models; Added unit tests for LocationViewModel; Added unit tests for Logs feature query logic and ViewModel state management; Added unit tests for Mock Rules ViewModel and transaction prefilling; Added unit tests for PreferencesViewModel and search debounce logic; Added unit tests for SlidingWindowRate; Added unit tests for WebSocketViewModel; Added unit tests for database repository and view model; Added unit tests for domain entities; Added unit tests for feature module ViewModels; Added unit tests for preferences data layer; Added unit tests for the Dependencies Inspector ViewModel.
Dependencies
Gradle wrapper upgraded to version 8.11.1
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
Migrate to Gradle Version Catalog and modularize build configuration
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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 57 → 62 (+5.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 79 → 79 (+0.0)
- Architecture 95 → 95 (-0.1)
- Maturity 63 → 69 (+5.5)
- Readiness 41 → 51 (+10.1)
- Security 72 → 65 (-6.9)
- Domain Modelling 77 → 77 (+0.0)
- Performance 78 → 100 (+21.7)
Resolved (4)
- Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
- Scanner failed to run — not a clean result
- Scanner failed to run — not a clean result
- Split features/viewer
New (246)
- Flaky test: com.azikar24.wormaceptor.feature.logs.vm.LogsViewModelTest$initial state.search query is empty()
- Outdated (compile): com.charleskorn.kaml:kaml
- Outdated (compile): com.charleskorn.kaml:kaml-jvm
- Outdated (compile): com.google.accompanist:accompanist-drawablepainter
- Outdated (compile): com.google.api.grpc:proto-google-common-protos
- Outdated (compile): com.google.auto.value:auto-value-annotations
- Outdated (compile): com.google.auto:auto-common
- Outdated (compile): com.google.code.gson:gson
- Outdated (compile): com.google.crypto.tink:tink
- Outdated (compile): com.google.crypto.tink:tink-android
- Outdated (compile): com.google.dagger:dagger
- Outdated (compile): com.google.devtools.ksp:symbol-processing-api
- Outdated (compile): com.google.errorprone:error_prone_annotations
- Outdated (compile): com.google.guava:failureaccess
- Outdated (compile): com.google.guava:guava
- Outdated (compile): com.google.j2objc:j2objc-annotations
- Outdated (compile): com.google.protobuf:protobuf-java
- Outdated (compile): com.google.protobuf:protobuf-java-util
- Outdated (compile): com.google.protobuf:protobuf-kotlin
- Outdated (compile): com.pinterest.ktlint:ktlint-cli-ruleset-core
- …and 226 more
Changes since last survey
- 5 commits — 4 feature/other, 1 fixes
By area
- (repo) — 2 commits
- build-logic/src — 1 commit
- features/preferences — 1 commit
- scripts/device.sh — 1 commit
Notable commits
- fix: Merge pull request #73 from wormaceptor/fix/maven-auto-release
- change: Merge todo/401e08ac (2a6dfcce): shared emulator and adb script
- change: build(publishing): release maven central deployments automatically
- change: chore(dev): add scripts/device.sh for shared emulator and adb
- change: test(preferences): stop relying on listFiles order
Architecture
- Unchanged — 0 containers · 32 contexts · 57 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 2300da514731b551a6a6272a1340f2aa87442f37 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-bb0cb800cd0f.