ambleside138/TimeRecorder

TimeRecorder is a Windows desktop application designed for granular time tracking and task management. It allows users to log working hours, manage to-do lists, and organize work processes, clients, and products. The system supports calendar synchronization, CSV data import/export, and local or cloud-based persistence via SQLite and Firebase.

67 changes.

This period established the foundational architecture of the TimeRecorder application, introducing a multi-layered structure with domain models, repositories, and a WPF-based user interface. Key features implemented include time tracking, task management, and data persistence via SQLite, alongside system utilities for configuration and reporting.

9 changes.

This period focused on implementing a new Todo management feature, including domain models, use cases, and a complete Firebase-based repository layer for persistence. Concurrently, the project introduced SQLite-based storage for time segments and time card links, expanding the application's data handling capabilities.

Users can now import working hour data from CSV files. The new CsvWorkingHourImportDriver reads Shift-JIS encoded CSVs, mapping date and time fields to domain models for processing.

src/TimeRecorder.Driver.CsvDriver/Import · high confidence

Users can now have their todo lists and individual todo items persisted to Firebase Firestore. This change introduces the data access layer for the Todo feature, including DAOs and document models for TodoList and TodoItem, along with the corresponding repository classes (FirestoreTodoListRepository and FirestoreTodoItemRepository) that handle CRUD operations against the NoSQL database.

src/TimeRecorder.Repository.Firebase/Todo · high confidence

Introduces a new Firebase-based implementation of the account repository, enabling Google OAuth sign-in and user registration in Firestore. The system now persists user profiles (display name, email, photo URL) and tracks the latest sign-in timestamp, while also providing a local login cache mechanism to support quick re-authentication and logout functionality.

src/TimeRecorder.Repository.Firebase/System · medium confidence

The application can now import scheduled events from a user's Google Calendar. A new \GoogleApiScheduledEventRepository\ was added to fetch events within a specified time range, filtering out events without specific start/end times, non-matching types, and zero-duration events. This enables the system to sync calendar data for time tracking purposes.

src/TimeRecorder.Repository.GoogleAPI/Calendar · high confidence

Users can now retrieve client lists from a Google Spreadsheet. The new \GoogleApiClientSourceRepository\ uses the Google Sheets API to fetch data from a 'Client Master' sheet, with the specific column (A or B) determined by the task category. A new \CredentialProvider\ handles authentication using a \credentials.json\ file and manages token storage.

src/TimeRecorder.Repository.GoogleAPI · high confidence

Introduced three new utility classes in the SQLite repository layer: ConnectionFactory, which manages SQLite database connections; DaoBase, an abstract base class providing connection and transaction access; and RepositoryAction, which provides static methods for executing queries and transactions with automatic connection management and transaction rollback on failure.

src/TimeRecorder.Repository.SQLite/Utilities · high confidence

Users can now have their daily working hours and specific time-tracking entries for tasks persisted to the local SQLite database. This change introduces new Data Access Objects (DAOs) and table row models for 'WorkingHour' and 'WorkingTime', enabling the application to store, update, and retrieve records of daily work hours and individual time entries linked to specific tasks.

src/TimeRecorder.Repository.SQLite/Tracking/Dao · high confidence

The application now stores and retrieves product information using a SQLite database. This change introduces a new data access layer that maps product records to domain objects, enabling the system to persist product details such as name, short name, and category filters in the local database.

src/TimeRecorder.Repository.SQLite/Products · high confidence

The application now stores and retrieves work processes using SQLite. A new repository layer (SQLiteWorkProcessRepository) and data access objects (WorkProcessDao, WorkProcessTableRow) have been introduced to handle the 'processes' table, including fields for title, invalid status, and task category filters. This change enables the UI to load and display work processes from the database rather than relying on in-memory or other storage mechanisms.

src/TimeRecorder.Repository.SQLite/WorkProcesses · high confidence

A new \SQLiteDailyWorkRecordQueryService\ has been introduced to handle querying daily work records from the SQLite database. This service implements the \IDailyWorkRecordQueryService\ interface, executing a SQL query to retrieve working time data and joining it with task, process, product, client, and segment information. It returns \DailyWorkResults\ containing both the list of working time records and working hours for a specified year and month.

src/TimeRecorder.Repository.SQLite/Tracking/Reports · high confidence

Users can now edit the date and time of a work unit via a new 'WorkingTimeRangeEditDialog' interface. This dialog allows users to select a date and enter start and end times in HHmm format, with validation ensuring the input is in the correct format. The change introduces the XAML view, the associated ViewModel classes (WorkingTimeRangeEditDialogViewModel and WorkingTimeViewModel) that handle the binding and validation logic for the editing process.

src/TimeRecorder/Contents/WorkUnitRecorder/Tracking · high confidence

The in-memory data access layer now includes concrete repository implementations for managing clients, todo items, and work processes. ClientRepository provides a static list of hospital and clinic records, while InMemoryTodoRepository handles the creation, deletion, and retrieval of todo items. ProcessRepository manages work process entries, and a shared RepositoryBase class provides common add, edit, and delete operations for these entities.

src/TimeRecorder.Repository.InMemory · high confidence

Users can now retrieve all time segments from the database. This change introduces a new repository layer for segments, including the ISegmentRepository interface, a SQLite implementation (SQLiteSegmentRepository), and the necessary Data Access Objects (SegmentDao, SegmentTableRow) to map database rows to domain objects.

src/TimeRecorder.Domain/Domain/Segments, src/TimeRecorder.Repository.SQLite/Segments · high confidence

Users can now access the Archive section to view a list of past working time records. The new ArchiveManager provides a date picker to select specific days, displaying a list of time records with options to edit the time range or the associated task details via modal dialogs.

src/TimeRecorder/Contents/Archive · high confidence

A new ClientUseCase class has been introduced in the domain layer to handle interactions with the client repository. It provides methods to retrieve all clients and add new client records, serving as the primary interface for client-related operations within the application.

src/TimeRecorder.Domain/UseCase/Clients · high confidence

Introduced new shared classes to support Firebase integration: \FirebaseAuthenticator\ handles Google OAuth and Firebase sign-in, \FirestoreAccessor\ manages Firestore database connections with automatic token refresh, and \FirebaseCredentialConfig\/\FirebaseCredentialConfigLoader\ manage project credentials. These changes enable the application to authenticate users via Firebase and interact with Firestore.

src/TimeRecorder.Repository.Firebase/Shared · high confidence

A new UserConfigurationManager class has been introduced in the Configurations folder to manage application settings. This singleton manager loads configuration items via a ConfigurationUseCase and provides generic GetConfiguration and SetConfiguration methods, allowing the application to persist and retrieve user-specific settings through a unified interface.

src/TimeRecorder/Configurations · high confidence

Added a new set of value converters in the TimeRecorder application to support data binding in the user interface. These include: DateTimeToFormattedStringConverter for formatting dates, EnumToBooleanConverter for radio button state binding, EnumToDisplayTextConverter and EnumToIconKeyConverter for resolving enum display text and icon keys via attributes, IntToVisibilityConverter and StringToVisibilityConverter for controlling element visibility based on integer or string values, and TaskCategoryToSolidBrushConverter for mapping task categories to specific UI colors.

src/TimeRecorder/Converters · high confidence

A new batch script, build/ReleaseBuild.bat, was added to automate the release build process for Windows. This script cleans the Release directory, creates it, and then executes a .NET publish command to produce a single-file, self-contained executable for win10-x64.

build · high confidence

The domain layer now includes two new exception classes: NotFoundException, which is thrown when a requested resource cannot be found, and SpecificationCheckException, which wraps validation results to provide structured error details. These exceptions allow the application to handle specific failure modes more precisely.

src/TimeRecorder.Domain/Utility/Exceptions · high confidence

A new demo mode is now available, allowing users to run the application with pre-configured sample master data. To use this, users must copy the 'timeRecorder.sqlite' file to the same directory as the executable. The demo includes sample data for products, work processes, and users, which are managed via a database master.

demo · high confidence

Added new base classes and interfaces to the domain layer to support domain-driven design patterns. This includes an abstract Entity base class for identity and equality comparison, a ValueObject base class for immutable value types, an Identity value object for managing entity IDs, and a NotificationDomainModel base class that provides property change notification capabilities. Additionally, an IRepository marker interface and an IIdentifiable interface were introduced to support repository patterns and identity checks.

src/TimeRecorder.Domain/Domain/Shared · high confidence

Added two new internal helper classes in the Firebase repository layer. DocumentSnapshotHelper provides a generic conversion method that attaches the document ID to a converted object. TimestampHelper adds extension methods to convert DateTime values to and from Firestore Timestamps, handling UTC conversion and local time zone adjustments.

src/TimeRecorder.Repository.Firebase/Shared/Helpers · medium confidence

New helper classes have been introduced in the TimeRecorder project to support core application functionality. CollectionHelper provides an extension method to add ranges of items to collections. JsonFileIO handles serializing and deserializing JSON files with built-in retry logic for file operations. TransitionHelper manages modal dialog transitions and responses (Yes/No/Cancel) using a messenger pattern. ValidatableReactiveProperty offers factory methods to create ReactiveProperty instances that ignore initial validation errors. These utilities support data persistence, UI navigation, and state management within the application.

src/TimeRecorder/Helpers · high confidence

Users will see frozen group headers in list controls, enabling easier reading of grouped data. Additionally, new interaction message actions allow for smoother visual transitions and modal window state management within the application's UI.

src/TimeRecorder/Behaviors · medium confidence

Users can now retrieve a list of all products. This is enabled by the new IProductRepository interface, which defines a SelectAll method, and the ProductUseCase class, which exposes a GetProducts method that delegates to the repository.

src/TimeRecorder.Domain/Domain/Products, src/TimeRecorder.Domain/UseCase/Products · medium confidence

The application introduces a comprehensive set of new styles and helper classes to support the Material Design UI framework. This includes custom styles for CheckBox, ListBoxItem, Expander, and TabControl, along with a Mac-like scrollbar and text block styles. These changes enhance the visual consistency and interactivity of the user interface, providing a modern, polished look across various controls.

src/TimeRecorder/Styles · high confidence

The domain layer for calendar integration has been expanded to support importing scheduled events as work tasks. A new repository interface (IScheduledEventFetch) and model (ScheduledEvent) enable fetching events by time range and kind. The core logic now uses a configurable builder (WorkTaskBuilder) that maps calendar titles to internal tasks using both legacy title mappers and a new schedule-title mapping system that includes product, client, process, and segment associations. This ensures that imported tasks are fully contextualized with segmentation and client data.

src/TimeRecorder.Domain/Domain/Calendar · high confidence

The src directory now contains the foundational project structure for the TimeRecorder application, including the solution file (TimeRecorder.sln) that defines the multi-project architecture (Domain, Repository, Driver, etc.), an .editorconfig for C\# code style and analyzer settings, and an AssemblyInfo.cs file that grants internal visibility to the test project.

src · high confidence

The TimeRecorder application is now available, providing a WPF-based desktop interface for time tracking and task management. The release introduces core features including a work unit recorder, an archive manager, an exporter, configuration settings, and a todo list. The application supports window position and state persistence, ensuring the UI layout is remembered between sessions. It also includes a system tray icon for quick access and notifications, along with a double-startup prevention mechanism to ensure only one instance runs at a time.

src/TimeRecorder · high confidence

The SQLite repository now includes a new Setup class that handles database initialization and schema versioning. Users benefit from automated database file creation and the ability to upgrade the database schema to the latest version, ensuring the application can manage its data structure over time.

src/TimeRecorder.Repository.SQLite · high confidence

Added repository interfaces for managing todo items and todo lists, along with the TodoItemIdentity record. The ITodoItemRepository defines methods to select, add, edit, and delete todo items, while ITodoListRepository provides similar operations for todo lists. These changes establish the data access contracts for the new Todo feature.

src/TimeRecorder.Domain/Domain/Todo · high confidence

Users can now create, edit, and manage Todo lists and individual tasks. This includes adding new tasks, marking them as complete or important, setting due dates, and filtering by completion status. The update also introduces a shared ConfirmDialog for user confirmations and a DateTimePicker for date selection, supporting the new scheduling features.

src/TimeRecorder/Contents/Todo · high confidence

Added a new WorkUnitRecorder component that provides the core UI and logic for recording work time and managing tasks. This includes a main view (WorkUnitRecorderView) displaying scheduled tasks and active work sessions, a model (WorkUnitRecorderModel) handling data loading and state, and a view model (WorkUnitRecorderViewModel) binding the UI to the domain logic. The feature adds support for manual and shortcut-based task creation, time card link management, and lunch time notifications, all integrated into the application's navigation rail.

src/TimeRecorder/Contents/WorkUnitRecorder · high confidence

Added new domain value objects for handling dates without time components. The YmdString class represents a date string (e.g., '20231025') with utilities for comparison, empty/now/tomorrow states, and conversion to DateTime. The YearMonth class represents a year and month pair, providing methods to check if a date falls within that month and to calculate the start and end dates of the month. These changes support more robust date handling in the TimeRecorder domain.

src/TimeRecorder.Domain/Domain/Terms · high confidence

The domain layer for time tracking now includes new entities and value objects to manage working hours and time ranges. Users can now track work periods via the new TimePeriod and WorkingHour domain models, which handle start/end times, duration calculation, and overlap detection. The system also introduces repository interfaces (IWorkingHourRepository, IWorkingTimeRangeRepository) and a specification (WorkingTimeRegistSpecification) to enforce business rules, such as preventing overlapping time entries and ensuring tasks are properly assigned. Additionally, a WorkTimeRuleDomainService defines the logic for determining the working date based on a 7 AM cutoff.

src/TimeRecorder.Domain/Domain/Tracking · high confidence

Added new domain models for task management: IWorkTaskRepository for data access, ImportedTask to track imported calendar events, and TaskCategory to categorize tasks (e.g., Development, Research, Maintenance). Also added TaskCategoryFilter to enable filtering tasks by category, and TaskSource to distinguish between normal, favorite, and schedule-sourced tasks.

src/TimeRecorder.Domain/Domain/Tasks · high confidence

Users can now create, edit, complete, and delete tasks, as well as start, stop, and edit time tracking for those tasks. This includes a new WorkTaskModel and ViewModel that bridge the UI with domain use cases, enabling features like task completion status, time range editing, and task deletion.

src/TimeRecorder/Contents/WorkUnitRecorder/Tasks · high confidence

A new vertical navigation rail is added to the application, featuring a tabbed interface with custom styling for selected and hover states. The implementation includes view models (NavigationIconButtonViewModel, NotSelectableNavigationItem) and a XAML resource dictionary that defines the visual template for the rail, allowing users to switch between different sections of the app via a side panel.

src/TimeRecorder/NavigationRail · high confidence

The application now supports dynamic theme switching via a new \ThemeService\ that applies Material Design swatches, and includes a \NotificationService\ that delivers Windows toast notifications for task reminders and lunch breaks. A \SnackbarService\ is added to display status messages to the user, and a \DialogHostHelper\ provides a standardized way to show dialogs. Additionally, \MainModel\ implements a health check that automatically upgrades the local database or creates it if missing, ensuring the application initializes correctly on first run or after schema changes.

src/TimeRecorder/Host · high confidence

The domain layer for tracking reports now includes new classes to structure time data for reporting. DailyWorkRecordHeader and DailyWorkTaskUnit are introduced to group and summarize work tasks by day, including logic to calculate expected total work time with statutory break deductions. Additionally, MonthlyReportBuilder is added to aggregate daily records into a monthly report, iterating through each day of the month to compile working hours and task units.

src/TimeRecorder.Domain/Domain/Tracking/Reports · medium confidence

New domain classes and interfaces have been added to the system layer to support account management, configuration storage, and health checking. Specifically, the Account model now exposes EmailAddress, DisplayName, and Password properties. A ConfigurationItem class with JSON serialization/deserialization capabilities has been introduced alongside an IConfigurationRepository interface. Additionally, an IAccountRepository interface defines signin, signout, and sign-in status checking, while an IHealthChecker interface and SystemStatus enum provide the foundation for system health checks.

src/TimeRecorder.Domain/Domain/System · high confidence

The TimeRecorder.Domain layer now includes new domain entities: Client, Product, Segment, WorkProcess, and WorkTask, each with identity, properties, and factory methods. WorkTask links to clients, products, processes, and segments, and supports completion states. Todo-related models (TodoItem, TodoList, TodoListFactory) are also added, enabling todo list management with categories like Today, Important, and Future. These changes expand the domain model to support more granular time tracking and task organization.

TimeRecorder.Domain · high confidence

A new Exporter module has been introduced to the application, providing a dedicated interface for managing time and work-hour data. Users can now export monthly reports as CSV files, with an option to automatically adjust or complete missing work hours. The export process also copies the generated data to the clipboard for easy pasting. Additionally, the module supports importing working hours, either via a configured API endpoint or by uploading a CSV file, allowing users to synchronize external time-tracking data into the system.

src/TimeRecorder/Contents/Exporter · high confidence

Added four new components to the application's UI layer: a \CallMethodButton\ that triggers specified methods on click, a \RunnableHyperlink\ that opens URIs in the default browser, a \HeaderAdorner\ for custom header rendering, and a \VisualTreeUtil\ helper for traversing the visual tree. These additions provide new interactive elements and debugging utilities for the time recorder interface.

src/TimeRecorder/Controls · high confidence

The application now provides a dedicated Configuration view that allows users to manage several settings: select a UI theme color, specify a local folder for automatic database backups, set start and end times for lunch breaks, and register or edit favorite tasks. The view also displays the current version number and includes settings for schedule title mapping and todo list usage.

src/TimeRecorder/Contents/Configuration · high confidence

The application now supports configuration for various user preferences and features. Users can now set a visual theme, manage a list of favorite work tasks, configure a schedule title map, define working hour import parameters, set lunch break times, enable or disable a to-do list feature, and specify a backup path. These changes introduce new configuration classes that map to these specific settings, allowing the application to remember and apply these user choices.

src/TimeRecorder/Configurations/Items · high confidence

Two new C\# attributes have been added to the domain layer: DisplayTextAttribute, which stores a display text string for fields, and IconKeyAttribute, which stores an icon key string for fields. These attributes are now available for use in the TimeRecorder.Domain.Utility namespace.

src/TimeRecorder.Domain/Utility/Attributes · medium confidence

The domain layer for tracking reports now includes new abstractions and implementations for exporting monthly reports. Specifically, \ExportMonthlyReportUseCase\ orchestrates the export process, while \GetDailyWorkRecordHeadersUseCase\ retrieves daily work headers. The diff introduces \IDailyWorkRecordQueryService\ and \IReportDriver\ interfaces to decouple data access and export logic, alongside a new \WorkingTimeRecordForReport\ model that aggregates task, product, client, and segment details for reporting purposes.

src/TimeRecorder.Domain/UseCase/Tracking/Reports · medium confidence

Added a new \IQueryService\ marker interface in the UseCase namespace. Introduced \DateTimeParser\ utility for flexible date/time string parsing and formatting, and \JsonSerializerHelper\ to configure JSON serialization options (e.g., allowing trailing commas, pretty-printing, and full Unicode support). These utilities support new functionality such as importing working hours from CSV and calculating summary reports, as indicated by the addition of \ImportWorkingHourUseCase\ and related repository/driver interfaces.

src/TimeRecorder.Domain/Utility · high confidence

Added three new use-case classes in the System domain: AuthenticationUseCase (providing sign-in, sign-out, and sign-in status checks), CheckStatusUseCase (exposing system health via IHealthChecker), and ConfigurationUseCase (allowing retrieval and updates of configuration items). These classes implement the domain logic for system-level operations, delegating to their respective repositories or checkers.

src/TimeRecorder.Domain/UseCase/System · high confidence

A new TaskConfigEditDialog has been added to the application, providing a user interface for editing task configurations. The dialog includes fields for title, task category (such as development, research and development, introduction after contract, maintenance, and other), product, work process, client, and segment. The implementation includes the XAML layout, the code-behind, and a corresponding ViewModel that binds to the UI elements, enabling users to create and modify task settings through a dedicated configuration window.

src/TimeRecorder/Contents/Configuration/TaskConfigEditor · high confidence

The application introduces a new \TaskEditDialog\ and its supporting view models (\WorkTaskEditDialogViewModel\, \WorkTaskViewModel\, \ProcessViewModel\) located in the \Tasks/Editor\ directory. This new UI component allows users to edit tasks with a full set of fields including title, task category (e.g., Development, Research & Development), product, client, work process, and segment. The editor includes validation for required fields (title, process, segment) and supports quick-start and delete actions.

src/TimeRecorder/Contents/WorkUnitRecorder/Tasks/Editor · medium confidence

A new timeline-based interface for visualizing and managing work units has been introduced. This includes a \TimelineCanvas\ for rendering the time grid, a \TimelineProperties\ class to manage display settings like hour height and start time, and a \TimelineWorkingTimeCard\ component that displays individual work items with their titles, categories, and durations. The view supports real-time duration updates and visually distinguishes between planned and unplanned tasks.

src/TimeRecorder/Contents/WorkUnitRecorder/Timeline · high confidence

The domain layer now includes new use cases for tracking working time: \WorkingHourUseCase\ for importing and managing start/end times, \WorkingTimeRangeUseCase\ for starting, stopping, editing, and deleting working time ranges, and \GetDailyWorkRecordUseCase\/\GetWorkingTimeForTimelineUseCase\ for retrieving daily and timeline data. These changes introduce new interfaces and DTOs to support the time-tracking feature.

src/TimeRecorder.Domain/UseCase/Tracking · high confidence

Added SQLite repository and data access objects for the Client domain entity, enabling storage and retrieval of client records (name, kana name) in the local database.

src/TimeRecorder.Repository.SQLite/Clients · high confidence

Added SQLite-backed implementations for system-level concerns: a new BackupWorker for database file backups, a ConfigDao and SQLiteConfigurationRepository to persist and retrieve system configuration items, and a SQLiteHealthChecker that validates the database file's existence and version consistency.

src/TimeRecorder.Repository.SQLite/System · high confidence

Added new Data Access Objects (DAOs) and row models for managing work tasks and completed task records in the SQLite repository. The new \WorkTaskDao\ and \WorkTaskTableRow\ classes handle the full lifecycle (insert, update, delete, select) for the \worktasks\ table, including support for filtering by completion status. Additionally, \WorkTaskCompletedDao\ provides methods to track and query completed tasks, while \ImportedTaskDao\ and \ImportedTaskTableRow\ introduce storage for imported task data, enabling the system to persist and retrieve imported task information alongside regular work tasks.

src/TimeRecorder.Repository.SQLite/Tasks/Dao · high confidence

Added new repository implementations for the SQLite database: SQLiteWorkingTimeRangeRepository handles CRUD operations for individual time ranges, SQLiteWorkingTimeQueryService provides read access to time entries with task and process details, and SQLiteWorkingHoursRepository manages daily working hour records. These changes enable the application to store and retrieve time tracking data using SQLite.

src/TimeRecorder.Repository.SQLite/Tracking · high confidence

The application now persists work tasks, their completion status, and associated time entries in a local SQLite database. This change introduces the data access layer for the 'Tasks' domain, including a repository for creating, editing, and deleting work tasks, as well as a query service that retrieves tasks along with their related client, product, and work process metadata, sorted by scheduled and active status.

src/TimeRecorder.Repository.SQLite/Tasks · high confidence

Users can now associate a URL with a time card for a specific year and month. This change introduces a new domain model (TimeCardLink) and a corresponding SQLite repository implementation to persist and retrieve these links.

src/TimeRecorder.Domain/Domain/TimeCards, src/TimeRecorder.Repository.SQLite/TimeCards · high confidence

A new specification, WorkTaskCompletionSpecification, has been introduced to validate whether a work task can be completed. This check ensures that the task has at least one recorded time entry and that no time range is currently marked as 'doing' (active), preventing completion if the task is still in progress.

src/TimeRecorder.Domain/Domain/Tasks/Specifications · high confidence

The application now supports selecting and registering work processes. A new domain model introduces an IWorkProcessRepository interface and a WorkProcessService that checks for title duplicates. The WorkProcessUseCase exposes GetProcesses to retrieve all processes and a Regist method that creates a new WorkProcess, validates for duplicates, and persists it via the repository.

src/TimeRecorder.Domain/Domain/WorkProcesses, src/TimeRecorder.Domain/UseCase/WorkProcesses · medium confidence

New use-case classes, TodoItemUseCase and TodoListUseCase, have been added to the domain layer. These classes expose standard CRUD operations (Add, Edit, Delete, Select) for managing individual todo items and todo lists, with the list selection method ordering results by display order.

src/TimeRecorder.Domain/UseCase/Todo · medium confidence

Introduced the WorkTaskCompletionCommand class, which provides methods to complete a work task (validating against a completion specification) and to restart a previously completed task, allowing users to manage the lifecycle of their tracked work sessions.

src/TimeRecorder.Domain/Domain/Tasks/Commands · medium confidence

Added new repository interfaces for managing clients: IClientRepository for basic CRUD operations and IClientSourceRepository for retrieving clients by task category, enabling domain logic to interact with client data.

src/TimeRecorder.Domain/Domain/Clients · high confidence

Added a new system clock utility in the domain layer, featuring an ISystemClock interface with a Now property, a DefaultSystemClock implementation that returns the current system time, and a FixedSystemClock for testing with a fixed time. A SystemClockServiceLocator is also introduced to manage the current clock instance, allowing the application to switch between real and fixed time sources.

src/TimeRecorder.Domain/Utility/SystemClocks · high confidence

The CSV report driver now supports both the new and legacy export formats. Users can choose which format to use when generating monthly reports. Additionally, the generated CSV data is automatically copied to the system clipboard, and warnings about input errors are handled without triggering a warning state.

src/TimeRecorder.Driver.CsvDriver/Export · medium confidence

The domain layer for tasks has been expanded with new use cases and services. A new \GetWorkTaskWithTimesUseCase\ and \IWorkTaskWithTimesQueryService\ provide a way to retrieve work tasks along with their associated time tracking data. An \ImportTaskFromCalendarUseCase\ has been added to import and update tasks from calendar events, handling both new and existing task synchronization. Additionally, the \WorkTaskUseCase\ now exposes methods to complete, uncomplete, and delete tasks, with deletion cascading to remove associated working time ranges.

src/TimeRecorder.Domain/UseCase/Tasks · medium confidence

The SQLite repository introduces a versioned schema migration system, starting at version 000.000.000.000 and progressing through 000.017.000.002. This includes the creation of initial tables (worktasks, workingtimes, processes, clients, products, systemversionlog), followed by incremental changes: adding columns like source, importkey, istemporary, displayorder, invalid, reportnameonly, and segmentid to existing tables; creating new tables for configs, workinghours, importedtasks, worktasksarchive, worktaskscompleted, segments, and timecardlinks; and dropping the worktasksarchive table. The VersionManager static class manages these versions, allowing the application to track and apply database schema changes over time.

src/TimeRecorder.Repository.SQLite/System/Versions · high confidence

Added tests for Identity equality logic; Added tests for monthly report builder; Added unit tests for Client and Process use cases; Added unit tests for Entity identity verification; Added unit tests for TimePeriod domain logic.

The project has been upgraded to the .NET 6.0 Windows target framework, replacing the previous .NET 5 configuration. This change updates the build environment and includes specific dependency updates such as Microsoft.Extensions.DependencyInjection 6.0.0 and MessagePipe 1.7.1, ensuring compatibility with the new runtime.

(dependencies) · high confidence

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

• CAI 48 → 48 (+0.2)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 50 → 49 (-1.3)
• Architecture 91 → 91 (-0.0)
• Maturity 46 → 46 (+0.0)
• Readiness 37 → 37 (+0.0)
• Security 92 → 82 (-10.8)
• Domain Modelling 99 (new)

• Bounded contexts not declared
• LLM evaluation failed
• No exposed public API
• XML-doc coverage: TimeRecorder (src/TimeRecorder/TimeRecorder.csproj)
• XML-doc coverage: TimeRecorder.Domain (src/TimeRecorder.Domain/TimeRecorder.Domain.csproj)
• XML-doc coverage: TimeRecorder.Driver.CsvDriver (src/TimeRecorder.Driver.CsvDriver/TimeRecorder.Driver.CsvDriver.csproj)
• XML-doc coverage: TimeRecorder.Repository.Firebase (src/TimeRecorder.Repository.Firebase/TimeRecorder.Repository.Firebase.csproj)
• XML-doc coverage: TimeRecorder.Repository.GoogleAPI (src/TimeRecorder.Repository.GoogleAPI/TimeRecorder.Repository.GoogleAPI.csproj)
• XML-doc coverage: TimeRecorder.Repository.InMemory (src/TimeRecorder.Repository.InMemory/TimeRecorder.Repository.InMemory.csproj)
• XML-doc coverage: TimeRecorder.Repository.SQLite (src/TimeRecorder.Repository.SQLite/TimeRecorder.Repository.SQLite.csproj)
• dormant codebase — no living knowledge left to concentrate

• CommentedOutCode (src/TimeRecorder/Behaviors/GroupHeaderFrozenBehavior.cs)
• CommentedOutCode (src/TimeRecorder/WindowActivator.cs)
• Duplicated block (13 lines × 2) (src/TimeRecorder.Repository.SQLite/Tasks/Dao/WorkTaskTableRow.cs)
• Duplicated block (18 lines × 2) (src/TimeRecorder.Repository.Firebase/Todo/Dao/TodoItemDao.cs)
• Duplicated block (7 lines × 2) (src/TimeRecorder/Contents/WorkUnitRecorder/Tasks/WorkTaskModel.cs)
• End-of-life runtime: .NET net6.0
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain.Test/Domain/Tracking/Reports/MonthlyReportBuilderTest.cs)
• WriteOnlyPrivateField (src/TimeRecorder.Domain/UseCase/Tracking/GetDailyWorkRecordUseCase.cs)
• WriteOnlyPrivateField (src/TimeRecorder/Contents/Todo/TodoModel.cs)
• redundant comment (src/TimeRecorder/Messaging/Windows/ModalWindowActionMessage.cs)

• Unchanged — 2 containers · 1 contexts · 0 edges

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

ambleside138/TimeRecorder 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.