jpablodrexler/jp-photo-manager

This system is a comprehensive photo management platform comprising a .NET WPF desktop application and a Java/Angular web application. It enables users to catalog, organize, and manipulate digital assets through features like batch renaming, format conversion, directory synchronization, and duplicate detection. The platform supports advanced organization via smart albums, tagging, and analytics, while providing robust administration tools for user management and audit logging.

23 changes.

This period focused on establishing the foundational structure of the repository and refactoring the JPPhotoManager application into a layered architecture with comprehensive test coverage. Core features for asset management, including batch renaming, synchronization, and format conversion, were implemented across the domain, infrastructure, and UI layers. The work also involved setting up the multi-project solution with .NET 8, Spring Boot, and Angular, alongside integrating SQLite persistence and dark-themed UI controls.

69 changes.

The project established a hexagonal architecture for the backend, introducing comprehensive domain models, use cases, and infrastructure adapters for asset management, authentication, and smart albums. Concurrently, the frontend was scaffolded with Angular, implementing core UI features such as gallery browsing, album management, and session handling, while supporting infrastructure like Kubernetes deployment and extensive test suites were added.

This change introduces a complete set of Kubernetes manifests to deploy the JPPhotoManagerWeb stack, replacing the previous Docker Compose setup. The new configuration includes definitions for the backend and frontend services, along with all required infrastructure components: PostgreSQL, MongoDB, Kafka, Redis, Prometheus, and Grafana. It also provides an Ingress resource for external access and example templates for secrets and catalog volume mounts, enabling users to run the application on a Kubernetes cluster.

JPPhotoManagerWeb/k8s · high confidence

A new web app manifest (manifest.webmanifest) has been added to the public directory, enabling the application to be installed as a Progressive Web App. The manifest configures the app to run in standalone mode with a specific theme color and background color, and defines a set of icon assets ranging from 72x72 to 512x512 pixels to support various device densities and installation prompts.

JPPhotoManagerWeb/frontend/public · high confidence

Users can now view, restore, or permanently delete previously removed assets via a new Recycle Bin interface. This feature introduces a dedicated page that displays soft-deleted items in a paginated grid, allowing users to select individual assets or empty the entire bin. Actions include restoring selected assets to their original locations, permanently purging selected items, or clearing the bin entirely, with immediate feedback provided through confirmation snackbars.

JPPhotoManagerWeb/frontend/src/app/features/recycle-bin · high confidence

Users can now sign in via a new login form that accepts a username and password and displays error messages on failure. After a successful login, the application navigates to a specified return URL, but only if it is a safe, same-origin relative path; absolute or protocol-relative URLs are rejected and the user is redirected to the home page instead.

JPPhotoManagerWeb/frontend/src/app/features/auth · high confidence

The application now provides analytics data regarding storage usage, including a breakdown of file sizes by folder (capped at the top 20 with an 'other' category for the rest), distribution of file formats, photos per month, and rating distribution.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/analytics · high confidence

The analytics feature now provides a dedicated dashboard that visualizes photo storage usage through four distinct charts: a tree map for storage per folder, a pie chart for file format distribution, and vertical bar charts for photos per month and rating distribution. The component handles loading and error states, displaying a spinner while data is fetched and an error message if the request fails, powered by the Swimlane ngx-charts library.

JPPhotoManagerWeb/frontend/src/app/features/analytics · high confidence

The application now exposes Spring Boot Actuator health checks for three key infrastructure components. The database health indicator verifies connectivity by executing a simple query, the geocoding indicator performs a HEAD request to the configured base URL to confirm external service availability, and the thumbnail storage indicator checks that the configured directory exists and is writable. These indicators allow operators to monitor the operational status of these dependencies via the standard health endpoint.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/health · high confidence

The UI layer now includes three new value converters to improve how asset details are displayed. FileSizeConverter formats raw byte counts into human-readable strings (bytes, KB, MB, or GB). PixelSizeConverter extracts and displays the width and height of an asset in pixels. VisibilityConverter controls the visibility of UI elements based on whether a value is a NamedObject, hiding it when it is and showing it otherwise.

JPPhotoManager/JPPhotoManager.UI/Converters · high confidence

The JPPhotoManager.Common library introduces new static helper classes to standardize image handling and data persistence. BitmapHelper provides methods to load BitmapImages from byte buffers or file paths with rotation support, as well as encode images to JPEG or PNG formats. ExifHelper reads EXIF orientation metadata from image buffers and maps it to internal rotation values. FileHelper simplifies JSON persistence by offering generic methods to read and write strongly-typed objects to JSON files.

JPPhotoManager/JPPhotoManager.Common · high confidence

Users can now create and manage albums, including smart albums that automatically populate based on filter criteria such as search keywords, date ranges, and minimum star ratings. The albums list displays a 'Smart' badge for dynamic albums, and the album detail view shows a banner summarizing the active filter criteria. Users can edit these filters via a dedicated dialog, remove individual assets from static albums, and add assets to existing albums or create new ones directly from the gallery.

JPPhotoManagerWeb/frontend/src/app/features/gallery · high confidence

Users can now add, remove, and bulk-assign tags to assets. The system normalizes tag names, automatically creates new tags if they do not exist, and removes tags that are no longer referenced by any asset. Tag changes immediately invalidate the relevant search cache to ensure consistent results, and all tagging actions are recorded in the audit log.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/tag · high confidence

The backend module now includes a comprehensive set of automated quality-reporting scripts (complexity, code coverage, auth coverage, dead code, dependency staleness, license compliance, SCA vulnerability scanning, and mutation testing) that generate dated Markdown snapshots in docs/reports/. These scripts are orchestrated by a run-all script and supported by dedicated PMD rulesets for cyclomatic complexity trending. Additionally, a Dockerfile and .dockerignore have been added to enable containerized builds and execution of the backend service.

JPPhotoManagerWeb/backend · high confidence

The backend now supports persisting user theme preferences. New use-case implementations allow retrieving a user's theme mode (defaulting to 'dark' if none exists) and saving theme mode changes, enabling the application to remember and apply the user's preferred visual theme across sessions.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/preference · high confidence

The backend database schema has been extended to support several new capabilities. Users can now rate assets (0-5), tag them, and save search presets. Asset management includes soft-delete functionality (recycle bin), file type tracking, and support for audio and video files. Album management now supports smart albums with dynamic filters. User account features include role-based access control, dark mode theme persistence, and enhanced session management with user agent tracking for refresh tokens. Additionally, the cataloging process now utilizes Spring Batch for state management and tracks processing status for assets.

JPPhotoManagerWeb/backend/src/main/resources/db · high confidence

The domain layer now includes the data structures required for new asset management capabilities. This adds a BatchRenameResult entity and validation logic in the Asset class to support batch file renaming with configurable naming formats. It also introduces SyncAssetsConfiguration and ConvertAssetsConfiguration entities, along with their respective directory definitions and result models, to enable asset synchronization and format conversion workflows. Additionally, the domain now includes a Release entity to support release availability checks and an AboutInformation class for application metadata.

JPPhotoManager/JPPhotoManager.Domain · high confidence

The Duplicates feature now provides a dedicated view for identifying and managing duplicate images. Users can view duplicate groups, mark a specific file as the one to keep, and delete the remaining duplicates in a single action. A new full-path tooltip is displayed when hovering over any asset item to help users quickly identify the file location. The interface includes a refresh button to reload the list, displays the total count of duplicates, and shows error notifications if loading or deletion fails.

JPPhotoManagerWeb/frontend/src/app/features/duplicates · high confidence

The home page now displays a comprehensive dashboard showing the total number of catalogued folders and assets, the timestamp of the last catalog completion, and the total storage size used. It features a 'Recent Photos' strip that allows users to click a thumbnail to navigate directly to the gallery view for that specific asset and folder, and a 'Top Folders' list that visualizes the most active directories with asset counts and progress bars. An empty state is shown when no photos have been catalogued yet.

JPPhotoManagerWeb/frontend/src/app/features/home · high confidence

The frontend project in JPPhotoManagerWeb/frontend is initialized with a comprehensive set of configuration files that establish the build, testing, and deployment infrastructure. This includes an Angular application setup (angular.json, tsconfig files) configured for standalone components and SCSS styles, alongside a Dockerfile and nginx.conf for containerized deployment with API proxying. To support quality assurance, the diff introduces dedicated configurations for ESLint, code coverage (nyc), and a multi-tier Cypress testing strategy (real backend, mocked, and accessibility audits). Additionally, tooling for dependency analysis (knip), mutation testing (Stryker), and secret scanning (secretlint) is added to enforce code quality and security standards.

JPPhotoManagerWeb/frontend · high confidence

The home page stats section has been enriched to include a list of the 12 most recently added assets (showing filename, folder path, thumbnail, and file size) and the timestamp of the last completed catalog run. This data is fetched via the new GetHomeStatsUseCase, which aggregates counts for folders, assets, total file size, and duplicates, and is cached using Caffeine to improve load times for these hot read paths.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/home · high confidence

This change introduces the backend implementation for user management operations (create, delete, list, get current user, and update password) within the application layer. These use cases enforce role-based access control, restricting write operations (create, delete, update password) and listing to users with the ADMIN role via Spring Security's @PreAuthorize annotations. Additionally, user creation and password updates now validate password strength using a dedicated PasswordValidationService before persisting changes.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/user · high confidence

This change introduces the core configuration files for the JP Photo Manager backend, establishing the application's runtime environment. It configures PostgreSQL as the primary database with Flyway for schema migrations, while also integrating Redis for caching, MongoDB for EXIF data, and Kafka for SSE broadcasting. Security is addressed by providing an example JWT secret generation and configuring CORS origins. Operational capabilities are added via Spring Boot Actuator endpoints for health and Prometheus metrics, including HTTP latency histograms. Logging is standardized using Logback with JSON (Logstash) encoding for file output and structured console output, alongside a configurable recycle bin retention policy.

JPPhotoManagerWeb/backend/src/main/resources · high confidence

This change establishes the foundational structure of the repository by adding key configuration and documentation files. It introduces a .gitattributes file to enforce LF line endings for shell scripts and git hooks, ensuring cross-platform compatibility. A comprehensive .gitignore file is added to exclude build artifacts, IDE caches, and dependency folders. Security is addressed with a .secretlintignore file to prevent accidental exposure of credentials. The repository is now documented with a root README.md detailing both the WPF desktop application (.NET 8) and the web application (Java/Angular), a CLAUDE.md providing development guidance for AI assistants, and a CHANGELOG.md recording version history. Finally, the LICENSE file is updated to reflect the current copyright year.

(repo-wide) · high confidence

Users can now configure and execute batch conversions of image assets (e.g., PNG to JPEG) by defining source and destination directories, including subfolder options, and reordering or removing these conversion jobs. The feature ensures reliable state updates by replacing in-place array mutations with immutable signal updates, which guarantees that the UI correctly reflects changes when adding, removing, or reordering definitions. The interface guides users through a three-step process: configuring the conversion jobs, monitoring real-time progress via status messages, and reviewing detailed results including success/failure counts and error messages.

JPPhotoManagerWeb/frontend/src/app/features/convert · high confidence

The backend now supports cataloging and viewing audio files (.mp3, .flac, .wav, .aac, .ogg), extracting metadata like title, artist, and album art via the new AudioMetadataService. To improve performance, asset search results are now cached in Redis with a folder-aware key structure, and thumbnail storage uses a disk-first, Redis L2 cache pattern with configurable TTLs. Additionally, a scheduled catalog run mechanism has been added to automatically index assets at configurable intervals.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/service · high confidence

The folder navigation sidebar now displays folders as an expandable tree, allowing users to browse nested directory structures. The component loads the folder hierarchy via the FolderService, automatically grouping folders by parent path to reveal child nodes, and provides visual indicators (chevrons) for expandable items. Users can click folder nodes to select them, which emits a selection event and highlights the active path, while a loading spinner ensures the UI remains responsive during data retrieval.

JPPhotoManagerWeb/frontend/src/app/features/folder-nav · high confidence

Users can now view and manage active login sessions via a new Sessions page, where they can revoke individual sessions or sign out of all other devices. The application also migrates to Angular's zoneless change detection for improved performance, and adds a global error handler that displays user-friendly snack-bar notifications for unexpected errors.

JPPhotoManagerWeb/frontend/src/app · high confidence

The sync feature now provides a dedicated interface for managing asset synchronization definitions. Users can configure source and destination directories, toggle subfolder inclusion and missing-file deletion, and reorder or remove definitions via an interactive table. A 'Save & Run' action triggers the sync process, displaying real-time status updates and a final results summary showing copied and deleted counts, with error states highlighted for failed operations.

JPPhotoManagerWeb/frontend/src/app/features/sync · high confidence

The JPPhotoManager.Application project now provides a central Application facade (IApplication) that exposes core photo management capabilities to the rest of the system. This includes asset synchronization, conversion, cataloging, and batch renaming, as well as utilities for managing recent target paths, checking for new releases, and preventing multiple application instances. The implementation also handles thumbnail caching logic and database shrinking on close, serving as the primary entry point for these features.

JPPhotoManager/JPPhotoManager.Application · high confidence

This change adds a suite of data-transfer objects and event records to the backend's application layer, enabling structured communication for asset upload, cataloging, conversion, and synchronization processes. New records such as \AssetUploadedEvent\, \AssetCatalogedEvent\, and \AssetDeletedEvent\ carry metadata like asset IDs, file paths, and user identifiers, while progress-oriented messages (\UploadProgressMessage\, \CatalogProgressMessage\, \ConvertProgressMessage\, \SyncProgressMessage\) facilitate tracking the state of long-running background tasks. Supporting types include \PaginatedData\ for list responses, \AlbumFilterJson\ for search criteria, and result objects (\ConvertAssetsResult\, \SyncAssetsResult\) for operation outcomes. Additionally, the main application class is configured with \@EnableAsync\ to support these asynchronous operations.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/dto · high confidence

The view models now support sorting assets by file name, size, and creation/modification date, with configurable ascending or descending order. A new duplicate detection workflow allows users to identify and manage duplicate assets, including the ability to delete them directly from the view. Additionally, a new asset conversion process enables users to convert assets from PNG to JPEG format, with configurable source and destination paths and options to include sub-folders or delete source files.

JPPhotoManager/JPPhotoManager.UI/ViewModels · high confidence

This change establishes the core data structures for the JPPhotoManagerWeb frontend by adding a new set of TypeScript interfaces in the \core/models\ directory. These models define the shape of data for key features including asset management (supporting images, audio, and video), album organization with dynamic filters, user authentication and session handling, and social media image cropping with 12 preset formats. Additionally, it introduces models for storage analytics, timeline views, batch renaming, and background synchronization, providing the type safety and contract definitions required for the application's UI and service layers.

JPPhotoManagerWeb/frontend/src/app/core/models · high confidence

This change adds several new infrastructure services to the application. The StorageService now handles file operations, directory resolution (including versioned data directories), and image processing tasks such as loading bitmaps, reading EXIF orientation, and converting images between PNG and JPEG formats. A new AssetHashCalculatorService provides SHA512-based hashing for asset content verification. Additionally, the UserConfigurationService has been updated to support file format versioning in application data paths and includes logic for setting desktop wallpapers. The GitHubReleaseAvailabilityService enables checking for the latest application releases via the GitHub API, while the ProcessService allows the application to detect if it is already running.

JPPhotoManager/JPPhotoManager.Infrastructure/Services · high confidence

This change introduces three new UI controls for the photo manager: a folder navigation tree that displays folder icons and updates dynamically when folders are added or removed; a thumbnail gallery that presents paginated assets with file details and supports extended selection; and an image viewer that displays high-quality images with a blurred background, navigation buttons, and zoom capabilities that allow zooming out only when scrollbars are visible.

JPPhotoManager/JPPhotoManager.UI/Controls · high confidence

The application now includes a dedicated infrastructure layer for data persistence, introducing the AppDbContext class which manages database entities such as Assets, Folders, and RecentTargetPaths. The database connection is configured to use SQLite, with the file path dynamically resolved to the user's local application data folder and customized with the current user's name and file format settings. This change establishes the foundational data access mechanism for the JPPhotoManager application.

JPPhotoManager/JPPhotoManager.Infrastructure · high confidence

The backend now exposes a comprehensive set of new REST endpoints for managing albums (creation, updates, smart filters, and asset membership), assets (listing, timeline view, thumbnails, cropping, tagging, and batch operations), and user authentication (login, logout, token refresh, and session management). These controllers implement the web layer of the new hexagonal architecture, utilizing dedicated request/response DTOs and use-case ports to handle domain logic, while also introducing features like storage analytics, audit log viewing, and media streaming with byte-range support.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/controller · high confidence

The application now supports converting PNG images to JPEG format and synchronizing files between directories. Administrators can configure source and destination paths for both operations via the new \ConvertConfigRepository\ and \SyncConfigRepository\ use cases. The \ConvertAssetsUseCaseImpl\ processes PNG files asynchronously, sending progress updates via Kafka, while \SyncAssetsUseCaseImpl\ copies new files and optionally deletes files not present in the source, also reporting progress through Kafka. Both operations are restricted to users with the ADMIN role.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/convert, JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/sync · high confidence

This update introduces a suite of new domain services in the photo manager to handle core asset operations. Users can now batch rename assets using configurable formats, convert PNG images to JPEG with EXIF orientation handling, and synchronize directories by copying new files and optionally deleting extras. The cataloging process has been enhanced to track visited folders to prevent duplicate processing, clean up unused thumbnails, and detect new, updated, or deleted assets. Additionally, a new service detects duplicate assets based on file hash, and a utility service ensures unique destination paths during file operations to prevent overwrites.

JPPhotoManager/JPPhotoManager.Domain/Services · high confidence

The backend now includes dedicated use-case implementations for several asset operations. Users can crop images to social-media formats (CropAssetUseCaseImpl), rename files in batches with pattern support and collision checks (RenameAssetsUseCaseImpl), and move assets between folders with path validation and transactional integrity (MoveAssetsUseCaseImpl). A new timeline view groups assets by date with pagination (GetAssetsTimelineUseCaseImpl). Additional use cases cover downloading assets as a ZIP with audit logging (DownloadAssetsUseCaseImpl), viewing asset images with MIME detection and audit logging (GetAssetImageUseCaseImpl), retrieving EXIF data with caching (GetAssetExifUseCaseImpl), and managing the recycle bin (GetDeletedAssetsUseCaseImpl, PurgeAssetsUseCaseImpl, RestoreAssetsUseCaseImpl). These changes restructure how asset operations are handled in the application layer, improving reliability and user experience for common photo management tasks.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/asset · high confidence

The application introduces dedicated frontend services to support new product capabilities: AlbumService enables creating, updating, and managing albums with assets; AnalyticsService provides storage and usage statistics; and MediaPlayerService handles unified audio and video playback with queue management. Additionally, BackgroundSyncService implements offline mutation queuing using IndexedDB to ensure data integrity when the network is unavailable.

JPPhotoManagerWeb/frontend/src/app/core/services · high confidence

Added a suite of new Node.js scripts in the frontend \scripts/\ directory to generate dated markdown reports for various quality metrics. These include accessibility audits (\a11y-report.js\), bundle size analysis (\bundle-size-report.js\), code coverage trending (\code-coverage-report.js\), cyclomatic complexity hotspots (\complexity-report.js\ and \cyclomatic-complexity.js\), dead code detection (\dead-code-report.js\), dependency staleness (\dependency-staleness-report.js\), E2E run flakiness and timing (\e2e-run-report.js\), license compliance (\license-compliance-report.js\), Lighthouse performance and accessibility scores (\lighthouse-report.mjs\), and mutation testing (\mutation-report.js\). These scripts provide deeper visibility into frontend health, performance, and compliance beyond simple pass/fail gates.

JPPhotoManagerWeb/frontend/scripts · high confidence

This update introduces a suite of new shared components and utilities in the frontend. Users will see an About dialog displaying the app version and GitHub link, a catalog progress footer to monitor background indexing, and a password strength meter that validates passwords against length, uppercase, digit, and special character rules. The media viewer now includes a fullscreen overlay for playback controls and a new thumbnail component that displays star ratings. Additionally, a file-size pipe formats storage units, and an accent-color picker allows theme customization.

JPPhotoManagerWeb/frontend/src/app/shared · high confidence

Added five new shell scripts to the \JPPhotoManagerWeb/scripts/\ directory to streamline operations. \build-and-deploy-k8s.sh\ automates building Docker images, installing the ingress-nginx controller, applying Kubernetes manifests, and restarting pods, with specific handling for WSL kubeconfig detection. \cleanup-k8s.sh\ provides a safe way to tear down the entire \photomanager\ Kubernetes stack and remove local Docker images. \port-forward-k8s.sh\ manages background port-forwarding tunnels for Grafana, PostgreSQL, MongoDB, and Kafka, detecting existing forwards to avoid duplicates. \migrate-db.sh\ facilitates migrating a local PostgreSQL database into the Docker Compose environment. Finally, \run-all-quality-reports.sh\ offers a single entry point to execute both frontend and backend quality metrics suites, supporting flags to include E2E or mutation testing.

JPPhotoManagerWeb/scripts · high confidence

Administrators can now manage user accounts through a dedicated User Administration page. This interface allows admins to view a list of existing users, create new user accounts with username and password, and change passwords for existing users. It also supports deleting users, including a confirmation dialog to prevent accidental removal. The component includes validation for form inputs and displays error messages for failed operations such as loading users, creating accounts, or updating passwords.

JPPhotoManagerWeb/frontend/src/app/features/admin · high confidence

The application interface has been updated to a dark theme (black backgrounds, white text) across the main window and all dialogs. The 'Import new assets' feature has been renamed to 'Sync Assets' and now features a dedicated SyncAssetsWindow that allows users to configure source/destination directories, include subfolders, and delete assets not in the source. A new ConvertAssetsWindow has been added to handle asset conversion (e.g., PNG to JPEG). The duplicate detection experience is enhanced with a FindDuplicatedAssetsWindow that displays duplicate sets and individual assets with details like file size and pixel dimensions. The folder navigation dialog now uses an editable ComboBox with a persistent list of recent target paths. Keyboard shortcuts have been added for common actions like copy (Ctrl+C), move (Ctrl+M), delete (Del), and zooming (+/-).

JPPhotoManager/JPPhotoManager.UI/Windows · high confidence

Users can now view a list of their active sessions, which are identified by device hints (e.g., "Chrome on macOS") derived from the User-Agent header, and revoke individual sessions or all other sessions. This capability is implemented through new use cases (GetActiveSessions, RevokeSession) and a DeviceHintParser within the auth application layer, allowing users to monitor and manage their login activity across devices.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/auth · high confidence

Users can now create albums that automatically populate based on dynamic filters (such as date ranges, search terms, and ratings) rather than manually adding assets. The backend use cases in this package enforce that manual add/remove operations are blocked on these smart albums, while retrieval and summary operations dynamically evaluate the stored filter criteria to determine the album's contents.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/album · high confidence

The backend now exposes a comprehensive set of domain ports in the \port/out\ layer, defining the contract for external adapters. This includes repositories for managing assets, albums, tags, folders, and user preferences, alongside specialized ports for storage operations, thumbnail generation, and audio playlist parsing. Authentication is decoupled into dedicated ports for JWT handling, refresh tokens, and user registration, while additional ports support audit logging, search caching, and catalog run history, providing the structural foundation for the application's data and security operations.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/domain/port/out · high confidence

This change establishes the core domain contract layer by adding a comprehensive set of repository and service interfaces. It defines the API for managing photo assets (IAssetRepository), handling folder structures (IFolderRepository), and performing operations like cataloging, syncing, moving, and converting assets. It also introduces interfaces for storage operations (IStorageService), user configuration (IUserConfigurationService), and utility services such as hash calculation, batch renaming, and duplicate detection, laying the groundwork for the application's data and business logic.

JPPhotoManager/JPPhotoManager.Domain/Interfaces · high confidence

The backend now exposes a comprehensive set of use-case interfaces in the \domain/port/in\ layer, establishing the entry points for album management (create, update, delete, add/remove assets), asset handling (upload, download, crop, timeline, playlist, rename, rate, reprocess), authentication (login, logout, refresh, session management), and supporting features like analytics, audit logs, search presets, tags, and user preferences. This change defines the contract for how the application layer invokes domain logic, decoupling the core business rules from the web controllers and infrastructure.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/domain/port/in · high confidence

The JPPhotoManager application has been reorganized into a multi-project solution comprising Domain, Infrastructure, Application, UI, Common, and Tests projects, replacing the previous single-project structure. This architectural shift separates concerns, moving boilerplate code to a Common project and isolating UI and data access layers. Additionally, the project now includes a test-with-coverage.bat script that integrates Coverlet and ReportGenerator to automatically collect and generate HTML code coverage reports during testing, enhancing developer visibility into test quality.

JPPhotoManager · high confidence

A change to existing behaviour in JPPhotoManager/Images — 2 commits, 7 files.

JPPhotoManager/Images · medium confidence · unverified

A new publish profile (FolderProfile.pubxml) has been added to the project, configuring the application to publish to the local file system path C:\\JPPhotoManager. This profile targets the net8.0-windows10.0.17763.0 framework and is set to build in Release mode without being self-contained.

JPPhotoManager/JPPhotoManager.UI/Properties · high confidence

The backend now enforces rate limits on the login endpoint (10 requests per minute) and the catalog endpoint (5 requests per hour) using a distributed Redis-based bucket algorithm, returning a 429 status with a Retry-After header when limits are exceeded. Additionally, every HTTP request is now tagged with a server-generated UUID in the X-Request-ID response header and SLF4J MDC, enabling end-to-end log correlation for troubleshooting.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/filter · high confidence

The audit trail has moved from Postgres to MongoDB, introducing an append-only audit log collection that automatically creates necessary indexes (userId/timestamp compound and a 365-day TTL on timestamp) at startup. To ensure existing data remains readable after renaming audit action constants from PascalCase to UPPER\_SNAKE\_CASE, a legacy reading converter is registered to map old enum names to their new equivalents during deserialization.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/config · high confidence

The backend configuration package has been restructured to centralize application settings, introducing several key behavioral changes. Security is now enforced via a dedicated SecurityConfig that mandates stateless JWT authentication, applies per-IP rate limiting before authentication, and restricts /api/admin/\\ endpoints to ADMIN roles. To support this, a DataInitializer now automatically seeds a default 'admin' user on first startup (with a warning to change the password). Caching behavior has shifted from local Caffeine caches to a centralized Redis-backed CacheManager, ensuring cache consistency across multiple backend instances and handling Redis outages gracefully via a fail-open error handler. Additionally, asynchronous task execution now correctly propagates the SecurityContext to worker threads, and Kafka topics are explicitly configured to support decoupled, retry-aware upload processing.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/config · high confidence

The catalog asset processing has shifted from asynchronous loops to Spring Batch jobs, allowing long-running catalog updates to run in the background with progress tracking via a completion future. The duplicate asset detection logic now explicitly excludes assets with null hashes (in-flight uploads) and verifies file existence and size, preventing concurrent uploads from being falsely identified as duplicates.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/catalog · high confidence

The photo cataloging pipeline has been migrated from a hand-written asynchronous loop to a Spring Batch job that partitions work by folder, allowing multiple directories to be scanned in parallel. The new batch processor correctly distinguishes videos from images and extracts audio metadata (including album art) for audio files. Additionally, the writer now automatically detects and removes catalog entries for files that no longer exist on disk, preventing stale records from persisting after deletion.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch · high confidence

The application now uses a global HTTP interceptor to manage authentication errors and user feedback. When a request receives a 401 Unauthorized response, the system automatically attempts to refresh the access token; if the refresh succeeds, the original request is retried, but if it fails, the user session is cleared and they are redirected to the login page. Additionally, error responses from the server are displayed to the user via a temporary notification (snackbar), including specific error messages from the response body and request correlation IDs for debugging, while suppressing notifications for login failures to avoid duplicate error displays.

JPPhotoManagerWeb/frontend/src/app/core/interceptors · high confidence

The backend now provides a unified, structured JSON error format for all API requests. A new global exception handler intercepts errors—ranging from validation failures and missing resources to authentication issues and internal server errors—and returns standardized responses with specific HTTP status codes (4xx/5xx) and descriptive messages. This ensures that clients receive predictable error bodies instead of raw stack traces or inconsistent formats.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/exception · high confidence

The application's database schema has been updated to support new asset management features and improved data integrity. A new 'ConvertAssetsDirectoriesDefinitions' table was added to handle PNG to JPEG asset conversion, alongside a 'RecentTargetPaths' table to track recent target directories. The primary key strategy for core entities (Assets, Folders, SyncAssetsDirectoriesDefinitions) was migrated from string-based identifiers to auto-incrementing integers for better performance. Additionally, an 'Order' column was introduced to the sync definitions table to allow for custom sorting of sync tasks.

JPPhotoManager/JPPhotoManager.Infrastructure/Migrations · high confidence

The backend now processes new asset uploads asynchronously using three independent Kafka consumers (hash, EXIF, and thumbnail) that run concurrently, preventing one stage's failure from blocking the others and eliminating race conditions during database updates. Additionally, audit trail entries are now durably persisted via a dedicated Kafka listener that ensures exactly-once recording of catalog, sync, and conversion events across multiple backend instances, while search cache invalidation is also driven by Kafka to keep paginated results consistent after asset changes.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/kafka · high confidence

The application now enforces a strict password complexity policy for user creation and admin password changes. Passwords must be at least 12 characters long and include at least one uppercase letter, one digit, and one special character. If a password fails these requirements, a specific error is returned detailing the violations, preventing weak passwords from being set.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/exception · high confidence

The backend persistence layer has been restructured into a hexagonal architecture, introducing new JPA adapter implementations for core domain entities including Assets, Albums, Users, and Tags. This change enables smart albums that dynamically populate assets based on filter criteria, adds persistence support for audio assets (storing metadata like title, artist, and duration), and implements a dual-write strategy for refresh tokens that mirrors PostgreSQL writes to Redis for faster session validation. Additionally, an append-only audit trail is now persisted in MongoDB, and EXIF data is stored in PostgreSQL JSONB with an explicit flush to prevent silent transaction failures.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/persistence · high confidence

The folder management backend now includes specific use-case implementations for retrieving drive roots, initial directories, recent target paths, and sub-folders, with sub-folder lookups cached via Caffeine to improve read performance. Additionally, a new use case handles the cleanup of folders that no longer exist on disk, ensuring database records and associated thumbnails are removed in the correct order to maintain data consistency.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/folder · high confidence

The application now uses a new set of repository classes (Asset, Folder, ConvertAssetsConfiguration, RecentTargetPath, and SyncAssetsConfiguration) backed by Entity Framework Core to manage photo assets, folder structures, and various configuration settings. This replaces previous storage mechanisms, enabling structured persistence of asset metadata, thumbnail caching, and directory definitions for conversion and sync operations.

JPPhotoManager/JPPhotoManager.Infrastructure/Repositories · high confidence

The application now supports switching between dark and light visual themes, both utilizing a green primary color palette. The default appearance is set to dark mode, and the styling ensures consistent theming across Material components and custom UI elements like the sidebar, status bar, and thumbnails.

JPPhotoManagerWeb/frontend/src · high confidence

The web layer's object mapping has been migrated from hand-written code to MapStruct, introducing a suite of new mapper interfaces (such as AlbumWebMapper, AssetWebMapper, and SearchPresetWebMapper) and helper converters. This change standardizes how domain models are converted to and from request/response DTOs, ensuring consistent serialization of complex fields like album filters and search presets while reducing manual boilerplate in the API infrastructure.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/mapper · high confidence

The backend's domain model package has been reorganized and expanded to support new application capabilities. This includes new entities for smart albums (Album, AlbumData), storage analytics (AnalyticsData, FolderStorageEntry, FormatEntry, MonthlyCountEntry, RatingEntry), and a timeline view (TimelineGroup). Support for audio assets is now modeled via AssetAudio and AudioMetadata, while Exif data is handled by AssetExif and ExifMetadata. The change also introduces models for session management (SessionInfo, RefreshToken), audit logging (AuditEvent, AuditLogFilter), and user preferences (UserPreference). Additionally, utility records for pagination (PaginatedResult), search presets, and asset renaming have been added to the domain layer.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/domain/model · high confidence

The backend's domain layer now uses a consistent set of strongly-typed enums to define core business concepts. This includes an AuditAction enum for tracking specific user activities (such as viewing, tagging, or rating assets) and an AuditEntityType enum to categorize the affected resources. Role-based access control is formalized with an enum distinguishing ADMIN and VIEWER permissions. Asset handling is standardized through FileType (supporting images, audio, video, and playlists), ImageRotation, and ProcessingStatus enums. Additionally, new enums define SortCriteria (including rating), SocialMediaFormat presets for cropping, UploadStage progression, WallpaperStyle options, and a Reason enum for folder/asset lifecycle events.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/domain/enums · high confidence

The web layer now uses a structured set of Java records and classes in the \dto/request\ and \dto/response\ packages to define API inputs and outputs. Request DTOs (such as \AuthRequestDto\, \CreateAlbumRequestDto\, and \CreateUserRequestDto\) enforce validation constraints like \@NotBlank\ and \@NotEmpty\, ensuring that client inputs are strictly validated before processing. Response DTOs (including \AssetResponseDto\, \AlbumResponseDto\, and \LoginResponseDto\) standardize the data returned to the frontend, exposing specific fields like asset metadata, album details, and session information. This change replaces previous ad-hoc data structures with a consistent, type-safe contract for all web-facing interactions.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/dto · high confidence

The UI project has been restructured to use WPF with a new dark theme applied to menus and buttons, and it now initializes via a centralized dependency injection container that registers services like batch renaming, asset conversion, and release notifications, while configuring SQLite storage paths and logging.

JPPhotoManager/JPPhotoManager.UI · high confidence

The GetAuditLogUseCaseImpl now enforces strict access control: only users with the ADMIN role can view the full audit history. Regular users are restricted to viewing only their own audit events; attempts to view another user's history result in an AccessDeniedException. This ensures that sensitive audit trail data is not exposed to unauthorized users.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/audit · high confidence

The refresh token cookie is now scoped to the /api/auth path instead of being restricted to /api/auth/refresh. This change ensures that session-related endpoints (such as listing or deleting sessions) can correctly access the refresh token, resolving issues where the current session status was always reported as false and signing out from other contexts failed due to missing tokens.

JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web · high confidence

Add test configuration for Kafka, PostgreSQL, and Testcontainers; Added controller tests for album, analytics, asset, and tag endpoints; Added integration and unit tests for album, tag, EXIF, caching, and authentication features; Added integration tests for application, repository, and service components; Added test fixture files for folder structure testing; Added test helper for mocking configuration values; Added tests for Kafka-driven upload processing, audit logging, and multi-instance progress broadcasting; Added tests for rate limiting and request correlation filters; Added tests for the Spring Batch catalog pipeline; Added unit tests for AuthCookieFactory; Added unit tests for application-layer use cases and services; Added unit tests for backend infrastructure services; Added unit tests for core application services and UI components; Added unit tests for infrastructure health indicators; Added unit tests for persistence repository adapters and JPA specifications; Added unit tests for web mapper implementations; New Cypress E2E and accessibility test suites for the frontend; Tests for consistent JSON error response format.

The repository is initialized with a multi-project structure. The .NET desktop application (JPPhotoManager) targets .NET 8.0 (net8.0-windows7.0/net10.0.17763.0) using WPF, Entity Framework Core 8.0.0 with SQLite, and log4net. The web backend (JPPhotoManagerWeb) is built on Java 21 with Spring Boot 3.5.3, utilizing PostgreSQL, Flyway 11.7.2, Redis, MongoDB, Spring Batch, and Spring Security with JWT. The web frontend (JPPhotoManagerWeb/frontend) uses Angular 22.1.1 with Material, Zone.js, and Cypress 15.20.1 for testing. Quality gates are enforced via JaCoCo (80% coverage), Cyclomatic Complexity checks, and various reporting tools (Lighthouse, Secretlint, Knip).

(dependencies) · high confidence

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

• CAI 59 → 64 (+4.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 72 (-6.6)
• Architecture 83 → 83 (+0.0)
• Maturity 71 → 76 (+4.9)
• Readiness 70 → 66 (-4.2)
• Security 43 → 54 (+11.5)
• Domain Modelling 100 → 98 (-1.7)

• Bounded contexts not declared
• Change coupling: app.component.cy.ts ↔ gallery.component.cy.ts (JPPhotoManagerWeb/frontend/src/app/app.component.cy.ts)
• Coverage not measured — analyzer environment
• Critical CVE: [GHSA redacted] (JPPhotoManagerWeb/frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (JPPhotoManagerWeb/frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (JPPhotoManagerWeb/frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (JPPhotoManagerWeb/frontend/package-lock.json)
• Dependency hygiene not measured — no packages were read
• Duplicated block (10 lines × 2) (JPPhotoManager/JPPhotoManager.UI/ViewModels/ApplicationViewModel.cs)
• Duplicated block (10 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/service/M3uPlaylistParserServiceAdapter.java)
• Duplicated block (15 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/kafka/KafkaProgressListener.java)
• Duplicated block (5 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/controller/AuthController.java)
• Duplicated block (6 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/album/GetAlbumSummaryUseCaseImpl.java)
• Duplicated block (6 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/web/controller/ConvertController.java)
• Duplicated block (6 lines × 3) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch/CatalogAssetItemProcessor.java)
• Duplicated block (6 lines × 3) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch/CatalogAssetItemProcessor.java)
• Duplicated block (6 lines × 4) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch/CatalogAssetItemProcessor.java)
• Duplicated block (7 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/application/usecase/user/CreateUserUseCaseImpl.java)
• Duplicated block (7 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch/CatalogAssetItemProcessor.java)
• Duplicated block (7 lines × 2) (JPPhotoManagerWeb/backend/src/main/java/com/jpablodrexler/photomanager/infrastructure/batch/CatalogAssetItemProcessor.java)
• …and 65 more

• ClassTooLong: GalleryComponent (JPPhotoManagerWeb/frontend/src/app/features/gallery/gallery.component.ts)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/App.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Controls/FolderNavigationControl.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Controls/ThumbnailsUserControl.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Controls/ViewerUserControl.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/AboutWindow.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/ConvertAssetsWindow.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/FindDuplicatedAssetsWindow.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/FolderNavigationWindow.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/MainWindow.xaml.cs)
• CoverageExclusion (JPPhotoManager/JPPhotoManager.UI/Windows/SyncAssetsWindow.xaml.cs)
• Documentation: contradicts the code (docs/catalog-process.md)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Documentation: written for insiders (docs/authentication.md)
• Duplicated block (10 lines × 2) (JPPhotoManager/JPPhotoManager.UI/Windows/ConvertAssetsWindow.xaml.cs)
• Duplicated block (10 lines × 2) (JPPhotoManager/JPPhotoManager.UI/Windows/ConvertAssetsWindow.xaml.cs)
• Duplicated block (10 lines × 2) (JPPhotoManager/JPPhotoManager.UI/Windows/ConvertAssetsWindow.xaml.cs)
• Duplicated block (11 lines × 2) (JPPhotoManager/JPPhotoManager.Domain/Entities/ConvertAssetsDirectoriesDefinition.cs)
• …and 294 more

• 22 commits — 18 feature/other, 4 fixes

• JPPhotoManagerWeb/frontend — 8 commits
• .claude/skills — 6 commits
• (repo) — 3 commits
• JPPhotoManagerWeb/README.md — 2 commits
• JPPhotoManagerWeb/backend — 2 commits
• (root) — 1 commit

• fix: Add real-backend E2E suite, fix refresh-token cookie path, harden CI build
• fix: Fix CI: keep zone.js as a devDependency for Cypress Component Testing
• fix: chore: sync skill drift from pablo-web, fix stale docs/reports/ path
• fix: fix: rename coverage:report npm script to stop recursive CI hang
• change: Merge pull request #262 from jpablodrexler/feature/zoneless-change-detection-migration
• change: Merge pull request #263 from jpablodrexler/e2e-migration-to-cypress
• change: Merge pull request #264 from jpablodrexler/release/v2.4.0
• change: Migrate frontend to zoneless change detection
• change: chore: bump @angular/cli to 22.1.2 to match pablo-web
• change: chore: sync skill drift from pablo-web, add decision-record and features-batch-development
• change: docs: add v2.4.0 release notes
• change: docs: document quality-metrics report locations in README
• change: feat(code-reviewer): add 80% code coverage gate for backend and frontend
• change: feat(code-reviewer): add cyclomatic complexity check for backend and frontend
• change: feat(e2e): run the real E2E tier against a local k8s redeploy, not docker-compose
• change: feat(feature-development): add conditional E2E verification phase
• change: feat: add accessibility audit, mutation testing, secrets/license/SCA reports
• change: feat: add bundle-size, dependency-staleness, and E2E run/flakiness reports
• change: feat: add quality-metrics tooling, raise test coverage to 80%+, remove private-repo references
• change: feat: add run-all-quality-reports scripts for frontend and backend
• …and 2 more

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

jpablodrexler/jp-photo-manager 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.