AfterLutz/Akkatecture

Akkatecture is a .NET framework for building distributed, event-sourced applications using the Akka.NET actor model. It provides core infrastructure for managing aggregate state, long-running sagas, and scheduled jobs, while supporting horizontal scaling through cluster sharding and singleton patterns. The system also includes utilities for testing, query projections, and background job execution.

59 changes.

The project underwent a major structural overhaul, replacing the legacy CQRS and actor-based infrastructure with a new, modular design centered on Aggregate and Saga base classes. This period introduced comprehensive support for distributed computing via Akka.NET clustering, alongside new features for event sourcing, snapshotting, and ASP.NET Core integration.

16 changes.

This period focused on establishing a robust build and CI/CD infrastructure using FAKE and Azure Pipelines, alongside the introduction of a comprehensive job scheduling system. The team also expanded testing capabilities with new fixtures for aggregates, sagas, and multi-node clusters, while adding query consumers and command result types to enhance the framework's functionality.

The Akkatecture.Examples.Api project now includes a complete ASP.NET Core web application setup. This introduces a new example demonstrating how to integrate Akka.NET actors (such as the ResourceManager, ResourceCreationSagaManager, and storage handlers) into an ASP.NET Core application using dependency injection and MVC routing.

examples/web/Akkatecture.Examples.Api · high confidence

Added a new example application that demonstrates how to schedule and run jobs using the Akkatecture job scheduler. The example includes a configuration file setting the job scheduler tick interval and a program entry point that creates an ActorSystem, instantiates a JobManager for a print job, and schedules a repeated job execution.

examples/jobs/Akkatecture.Examples.JobApplication · high confidence

Added a new example demonstrating how to implement a scheduled job using the Akkatecture Jobs framework. This includes the job definition (PrintJob), its identifier (PrintJobId), the scheduler (PrintJobScheduler), the runner (PrintJobRunner) that logs the job content, and the associated response types (PrintJobResponses).

examples/jobs/Akkatecture.Examples.Jobs · high confidence

The Akkatecture cluster example is now runnable as three distinct applications: a client that sends commands to a cluster, a seed node that initializes the cluster, and worker nodes that process aggregates. Each application includes its own configuration file (client.conf, seed.conf, worker.conf) and entry point (Program.cs), allowing users to start a complete distributed system for testing clustering features.

examples/cluster/Akkatecture.Examples.Worker · high confidence

The examples/web/Akkatecture.Examples.Api/Controllers directory now includes new C\# files that implement the web API endpoints. BaseController.cs provides shared HTTP utilities, while OperationsController.cs exposes GET endpoints to list and retrieve operations. ResourceController.cs adds POST and GET endpoints for creating and retrieving resources, utilizing the underlying Akka-based message passing and query repositories. These changes introduce the concrete HTTP handling layer for the example application.

examples/web/Akkatecture.Examples.Api/Controllers · high confidence

A new abstract class ActorRefProvider has been introduced in the Akkatecture.Akka namespace to wrap Akka.NET's IActorRef. This class exposes the standard Tell and Ask messaging patterns, providing a consistent interface for sending messages and awaiting responses from actors. A generic variant ActorRefProvider\<T\> is also included, allowing type-safe interactions with specific actor types.

src/Akkatecture/Akka · high confidence

New files have been added to the Akkatecture library to support dependency injection in ASP.NET Core applications. This includes the AkkatectureBuilder class and its corresponding interface, along with extension methods (AddAkkatecture and AddActorReference) that allow users to easily register Akkatecture services and actor references within the standard .NET service collection.

src/Akkatecture/Configuration/DependancyInjection · high confidence

The Akkatecture library now includes a new \CommandResults\ namespace containing the \ICommandResult\ interface and its implementations (\SuccessCommandResult\, \FailedCommandResult\, and the base \CommandResult\ class). This introduces a structured way to represent the result of a command execution, allowing developers to distinguish between successful and failed command states with associated error details.

src/Akkatecture/Aggregates/CommandResults · high confidence

A new command and handler have been added to the Resource aggregate, allowing users to create a new resource. The handler checks if the resource already exists; if not, it emits a ResourceCreatedEvent and returns a SuccessExecutionResult. If the resource already exists, it returns a FailedExecutionResult with an error message.

examples/web/Akkatecture.Examples.Api/Domain/Aggregates/Resource/Commands · high confidence

Introduced the core entity model for the library. The new \Entity\<TIdentity\>\ abstract class and \IEntity\<TIdentity\>\ interface provide a standard way to define entities with a typed identity, enabling consistent identity management across the framework.

src/Akkatecture/Entities · high confidence

The example API now includes a new 'Resource' domain aggregate, consisting of the main Resource class, its ResourceId identifier, a ResourceState for managing state, and a ResourceManager for command handling. This adds a complete, albeit minimal, example of an aggregate root and its associated types within the Akkatecture framework.

examples/web/Akkatecture.Examples.Api/Domain/Aggregates/Resource · high confidence

The example API now includes a new saga implementation for managing the lifecycle of resource creation. This includes the main \ResourceCreationSaga\ which simulates a long-running process, along with supporting classes for state (\ResourceCreationSagaState\), identification (\ResourceCreationSagaId\), and event handling (\ResourceCreationStartedEvent\, \ResourceCreationProgressEvent\, \ResourceCreationEndedEvent\). This allows the system to track and update the progress of resource creation operations over time.

examples/web/Akkatecture.Examples.Api/Domain/Sagas · high confidence

A new extension method, FixtureFor, is now available on TestKitBase to simplify the setup of test fixtures for aggregates and aggregate managers. This addition provides a more convenient way to arrange test fixtures in unit tests, reducing boilerplate code when testing Akka.NET-based aggregate implementations.

src/Akkatecture.TestFixture/Extensions · high confidence

Added the UserAccount aggregate, its state, ID, and associated domain events (UserAccountCreatedEvent, UserAccountNameChangedEvent) to the example domain. This introduces the ability to create a user account and change its name, with the aggregate emitting corresponding events to update the account state.

examples/simple/Akkatecture.Examples.Domain/Model/UserAccount · high confidence

The example domain now includes new command classes, specifically CreateUserAccountCommand and UserAccountChangeNameCommand, which define the structure for creating a new user account and changing a user's name respectively. These additions provide the necessary interfaces for handling these specific user account actions within the Akkatecture framework.

examples/simple/Akkatecture.Examples.Domain/Model/UserAccount/Commands · high confidence

Introduced new classes in the Akkatecture.Clustering.Core namespace to support distributed computing patterns. The ClusterFactory class provides methods to start clustered aggregate managers and sagas using Akka Cluster Sharding, while the SingletonFactory enables running domain event subscribers as cluster-wide singletons. MessageExtractor classes were added to handle entity ID resolution for both aggregates and sagas, enabling proper sharding and proxying of distributed actors.

src/Akkatecture.Clustering/Core · high confidence

The Akkatecture library now includes a default configuration file (default.conf) and a corresponding settings class (AkkatectureClusteringDefaultSettings) that loads Akka.NET cluster and sharding settings. This provides a baseline for cluster sharding, including serializer bindings for JSON and cluster messages, and remote transport settings for .NETty. Users can now rely on these defaults or override them in their own HOCON configuration.

src/Akkatecture.Clustering/Configuration · high confidence

The Akkatecture.Jobs namespace now includes a complete job scheduling system. This introduces commands for scheduling jobs (including cron-based and repeated execution), cancelling scheduled jobs, and handling job ticks. It also adds the corresponding domain events (Scheduled, Cancelled, Finished) and the core interfaces and implementations (IJob, JobManager, JobScheduler, JobRunner) required to manage and execute background tasks within the framework.

src/Akkatecture/Jobs · high confidence

The Akkatecture library now includes several new specification classes in the \Akkatecture.Specifications.Provided\ namespace. These include \AggregateIsNewSpecification\, \AllSpecification\, \AndSpecification\, \AtLeastSpecification\, \ExpressionSpecification\, \NotSpecification\, and \OrSpecification\. These classes provide various ways to define and combine conditions for validating aggregate roots, supporting logical combinations (AND, OR, NOT) and expression-based checks.

src/Akkatecture/Specifications/Provided · high confidence

New query interfaces (IQueryOperations, IQueryResources) and their corresponding handlers (OperationsQueryHandler, ResourcesQueryHandler) have been added to the example API. These handlers expose Find and FindAll methods that retrieve data from in-memory storage handlers (OperationsStorageHandler, ResourcesStorageHandler), which subscribe to domain events (e.g., ResourceCreationStartedEvent, ResourceCreationEndedEvent) to maintain the latest state of Operations and Resources.

examples/web/Akkatecture.Examples.Api/Domain/Repositories · high confidence

The library introduces a new saga subsystem with a set of core interfaces and base classes. This includes the \ISaga\ marker interface, \ISagaHandles\ and \ISagaHandlesAsync\ for defining event handlers, \ISagaIsStartedBy\ to specify which events trigger a saga, and \ISagaLocator\ for finding saga instances. Additionally, \ISagaId\ and \ISagaName\ define identity and naming contracts, while \SagaId\ and \SagaName\ provide default implementations. The \SagaState\ abstract class is also added to manage message application within a saga's lifecycle.

src/Akkatecture/Sagas · high confidence

A new Program.cs file has been added to the Akkatecture.Examples.Application project, providing a runnable example that demonstrates how to create an ActorSystem, instantiate a UserAccountAggregateManager, and send commands to it.

examples/simple/Akkatecture.Examples.Application · high confidence

The \src/Akkatecture/Aggregates/Snapshot\ directory now contains a new set of classes and interfaces that provide the foundation for aggregate snapshotting. This includes the \CommittedSnapshot\ data model, the \IAggregateSnapshot\ interface and its generic variant, and the \IHydrate\ interface for restoring state. The change also introduces the \ISnapshotStrategy\ interface to determine when snapshots should be created, along with \ISnapshotHydrater\ for hydration logic. Additionally, the update adds \SnapshotDefinition\ and \SnapshotDefinitionService\ for managing snapshot metadata and versioning, supported by \SnapshotMetadata\, \SnapshotMetadataKeys\, \SnapshotId\, and the \SnapshotVersionAttribute\ for configuration.

src/Akkatecture/Aggregates/Snapshot · high confidence

The Akkatecture library now includes a new Specifications module featuring an ISpecification interface and an abstract Specification base class. This addition provides a standardized way to evaluate objects against specific criteria, allowing users to implement custom validation or filtering logic within the Akkatecture framework.

src/Akkatecture/Specifications · high confidence

Introduced new core types in the \Akkatecture.Core.VersionedTypes\ namespace to support versioned type definitions. This includes the \IVersionedType\ marker interface, the \VersionedTypeAttribute\ for marking types with name and version metadata, the \VersionedTypeDefinition\ base class for holding type metadata, and the \IVersionedTypeDefinitionService\ interface along with its \VersionedTypeDefinitionService\ implementation. These components provide a mechanism to register, store, and retrieve type definitions by name and version, enabling the framework to manage multiple versions of types.

src/Akkatecture/Core/VersionedTypes · high confidence

The Akkatecture.Core namespace now includes new interfaces for identity management (IIdentity, ISourceId) and metadata handling (IMetadataContainer), alongside a new SourceId implementation. Existing core classes like Identity, MetadataContainer, and ReflectionHelper have been restructured, with the latter gaining a new overload for compiling method invocations via MethodInfo. These changes provide a more explicit contract for identifying entities and accessing metadata, while improving the internal reflection utilities used by the framework.

src/Akkatecture/Core · high confidence

The library now provides default configuration for core components, including automatic subscription for aggregate saga managers and domain event subscribers, auto-spawning of child sagas, and default event recovery handlers for aggregates and sagas. Additionally, an in-memory journal is configured with an 'aggregate-event-tagger' adapter to tag all committed events, enabling event-based saga triggering and domain event subscription.

src/Akkatecture/Configuration · high confidence

Added the Aggregate Saga Manager component, which provides a base class for managing the lifecycle of aggregate-based sagas. This new manager automatically subscribes to domain events and snapshots based on configuration, and handles spawning and supervising individual saga actors. The implementation includes settings for auto-subscribing to events, auto-spawning on receive, and using default event/snapshot recovery, allowing developers to easily integrate saga patterns with Akka.NET's actor system.

src/Akkatecture/Sagas/AggregateSaga · high confidence

Added the DomainEventSubscriber base class and supporting configuration (DomainEventSubscriberSettings) to enable automatic subscription to domain events. The new subscriber automatically registers handlers for both synchronous (Handle) and asynchronous (HandleAsync) event processing, with configuration options to enable auto-subscription and auto-receiving of events.

src/Akkatecture/Subscribers · high confidence

Added new \AggregateRoot\ and \AggregateSaga\ base classes that provide the core infrastructure for managing aggregate state, handling events, and persisting snapshots. The \AggregateRoot\ class implements event sourcing with automatic recovery and snapshotting, while \AggregateSaga\ adds support for saga timeouts and state management. These classes form the foundation for building domain models and long-running processes within the Akkatecture framework.

Akkatecture · high confidence

Added a new build infrastructure centered on FAKE (F\# Make) scripts and Azure Pipelines YAML definitions. The \build\ directory now contains \build.fsx\ and supporting scripts (\build.cmd\, \build.ps1\, \fake.sh\, \fake.cmd\) that automate restore, build, test, and package steps. Four new Azure Pipelines definitions (\azure-pipelines-development-ci-cd.yaml\, \azure-pipelines-master-ci-cd.yaml\, \azure-pipelines-release-ci-cd.yaml\, \azure-pipelines-static-ci.yaml\) configure continuous integration and deployment workflows for development, master, and release branches, including SonarQube analysis and NuGet/GitHub releases. A \global.json\ file was added to pin the .NET SDK version to 6.0.408.

build · high confidence

A new test fixture implementation has been added to the Akkatecture.TestFixture library, providing a fluent API for arranging, executing, and asserting state in aggregate tests. The change introduces the AggregateFixture class along with its supporting interfaces (IFixtureArranger, IFixtureExecutor, IFixtureAsserter), enabling developers to set up aggregate state via events or snapshots, execute commands, and verify expected domain events, replies, and state transitions in unit tests.

src/Akkatecture.TestFixture/Aggregates · high confidence

A new Consumer class has been added to the Akkatecture.Query namespace, providing a fluent interface for querying events from the persistence layer. Users can now create a Consumer instance and use the Using\<TJournal\> method to specify a read journal, then call EventsFromAggregate or CurrentEventsFromAggregate to retrieve event streams for specific aggregate roots. This introduces a new way to access domain events in a strongly-typed manner.

src/Akkatecture/Query · high confidence

The library introduces a new \ExecutionResult\ hierarchy in the \Akkatecture.Aggregates.ExecutionResults\ namespace to represent the outcome of aggregate operations. This includes an \IExecutionResult\ interface, an abstract \ExecutionResult\ base class with \Success()\ and \Failed()\ factory methods, and concrete implementations for \SuccessExecutionResult\ and \FailedExecutionResult\ (which carries error messages).

src/Akkatecture/Aggregates/ExecutionResults · high confidence

Added a new \TypeExtensions\ class in the \Akkatecture.Clustering\ library that provides reflection-based helpers to discover event subscription types for Sagas and Domain Events. This enables the clustering system to automatically identify and subscribe to async and synchronous handlers for domain events, supporting the distributed saga functionality.

src/Akkatecture.Clustering/Extentions · high confidence

The \src/Akkatecture/Aggregates\ directory now contains the foundational classes and interfaces for the aggregate system, including \AggregateManager\ for routing commands and handling dead letters, \CommittedEvent\ to wrap published events, and \AggregateState\ for state management. The \Metadata\ class has been enhanced with \CorrelationId\ and \CausationId\ properties, and the \IEventApplier\ interface has been renamed to \IMessageApplier\ and extended to include snapshot hydration capabilities.

src/Akkatecture/Aggregates · high confidence

The library introduces a new set of classes and interfaces in the \Akkatecture.Events\ namespace to support domain event mapping, event upcasting, and event definition management. This includes the \DomainEventMapper\ and \DomainEventReadAdapter\ for converting committed events into domain events, an \AggregateEventUpcaster\ system with \IEventUpcaster\ and \IUpcast\ interfaces to handle event versioning and transformation, and supporting infrastructure like \EventDefinition\, \EventDefinitionService\, and \EventVersionAttribute\ to manage event metadata and versions.

src/Akkatecture/Events · high confidence

Added several new extension methods in the Akkatecture.Extensions namespace to improve type resolution and specification composition. TypeExtensions now provides utility methods to retrieve AggregateName, SagaName, and JobName from their respective types, as well as reflection-based methods to map aggregate and snapshot Hydrate/Apply methods. Additional extensions include functional binding for actions, actor context child resolution, Unix timestamp conversion, byte array conversion for identities, and a fluent API for combining specifications with And, Or, and Not operators.

src/Akkatecture/Extensions · high confidence

Added new types and classes to support saga timeouts, including the ISagaHandlesTimeout and ISagaHandlesTimeoutAsync interfaces for handling timeout events, the ISagaTimeoutJob marker interface, the SagaTimeoutId identity class, and the SagaTimeoutJobRunner, SagaTimeoutJobScheduler, and SagaTimeoutManager classes that manage the lifecycle and execution of these timeout jobs.

src/Akkatecture/Sagas/SagaTimeouts · high confidence

Added ShardedAggregateSagaDispatcher and SingletonDomainEventSubscriberDispatcher to the clustering library. These new Akka actors subscribe to domain events and route them to their respective cluster proxies, enabling distributed saga management and singleton-based event subscription across the cluster.

src/Akkatecture.Clustering/Dispatchers · medium confidence

Added three new snapshot strategies to the Akkatecture library: \SnapshotAlwaysStrategy\ (creates a snapshot on every event), \SnapshotNeverStrategy\ (never creates snapshots), and \SnapshotEveryFewVersionsStrategy\ (creates a snapshot every N versions, defaulting to 50). These classes implement the \ISnapshotStrategy\ interface, allowing users to configure how frequently their aggregate roots are snapshotted.

src/Akkatecture/Aggregates/Snapshot/Strategies · high confidence

Removed the entire \Akkatecture.Core\ module, including all classes and interfaces related to aggregate roots, events, commands, sagas, and messaging envelopes. This eliminates the framework's built-in support for CQRS patterns, Akka.NET actor-based aggregation, and saga management, requiring users to implement or adopt alternative infrastructure for these capabilities.

src/Akkatecture.Core · high confidence

The command-related types (Command, CommandHandler, ICommand, etc.) have been moved from the Akkatecture.Core namespace to the Akkatecture.Commands namespace. Similarly, value object types (ValueObject, SingleValueObject, etc.) have been moved from Akkatecture.Core.ValueObjects to Akkatecture.ValueObjects. This is a structural reorganization of the library's public API surface, requiring updates to any code that directly references these types by their fully qualified names.

src/Akkatecture/Commands · high confidence

Added a new ClusterParentProxy actor in the Clustering module that forwards messages to a child actor, automatically unsubscribing from all topics if configured. This change includes the introduction of the UnsubscribeFromAll message class, which was moved from the Core module to the Messages module, enabling actors to cleanly unsubscribe from all subscriptions upon initialization.

src/Akkatecture.Clustering, src/Akkatecture/Messages · medium confidence

The repository has been reorganized with a new build system (FAKE), updated solution structure, and upgraded dependencies including Akka.NET to 1.5.8, FluentAssertions to 6.11.0, and Microsoft.NET.Test.Sdk to 17.6.2. The project now targets netstandard2.0 and includes new assets such as a logo, sponsors list, and third-party notices.

(repo-wide) · high confidence

The example project's UserAccount domain model has been removed, including the \CreateUserAccountCommand\, \UserAccountChangeNameCommand\, \UserAccountCreatedEvent\, \UserAccountNameChangedEvent\, \UserAccountAggregate\, \UserAccountAggregateManager\, \UserAccountId\, and \UserAccountState\ files. This eliminates the previous implementation of the user account aggregate and its associated commands and events from the example codebase.

examples/Akkatecture.Examples.UserAccount · high confidence

The main entry point for the User Account example application has been removed. This eliminates the hardcoded demonstration of creating a user account via the aggregate manager, simplifying the example project structure.

examples/Akkatecture.Examples.UserAccount.Application · high confidence

Added Akka.NET configuration helpers for testing; Added integration tests for saga timeout handling; Added multi-node cluster tests for aggregates and sagas; Added multi-node test runner infrastructure; Added serialization tests for core domain types; Added test command fixtures for aggregate testing; Added test fixtures for aggregate event upcasting; Added test fixtures for aggregate testing; Added test fixtures for synchronous and asynchronous sagas; Added test helper classes and event definitions; Added test helper for state signal events; Added test helper specifications for validation logic; Added test helper utilities for categorization and serialization; Added test helpers for Jobs; Added test helpers for aggregate subscribers; Added unit tests for SingleValueObject serialization and equality; Added unit tests for TypeExtension methods; Added unit tests for aggregate event contracts and test fixtures; Added unit tests for clustering sharding message extraction; Added unit tests for command execution and result handling; Added unit tests for core utilities; Added unit tests for mapping components; Added unit tests for scheduled job execution; Added unit tests for subscriber event handling; Added unit tests for the Specifications component; Removed empty test helper project and build artifacts; Removed test build artifacts.

The project structure has been reorganized: the core library has been renamed from Akkatecture.Core to Akkatecture, and example projects have been moved into specific subdirectories (cluster, simple, web, jobs). Several example projects (ClusterClient, Seed, Worker, Application, Domain, Api) and test projects (TestFixture, TestHelpers, MultiNode, NodeTestRunner, Tests) have been added or restructured. Dependencies have been updated, including Akka packages, Microsoft.Extensions.DependencyInjection.Abstractions (7.0.0), Microsoft.CSharp (4.7.0), Newtonsoft.Json (13.0.3), and various test-related packages.

(dependencies) · medium confidence

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

• CAI 56 → 55 (-1.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 54 → 50 (-4.7)
• Architecture 97 → 97 (+0.0)
• Maturity 57 → 57 (+0.0)
• Readiness 71 → 71 (-0.1)
• Security 63 → 73 (+9.7)
• Domain Modelling 60 → 64 (+4.5)
• Event-Driven 83 → 83 (+0.0)
• Performance 54 → 54 (+0.0)

• Both 'AggregateEventUpcaster' and 'DomainEventReadAdapter' have a 'FromJournal' method that takes an object and a string manifest. This suggests a shared responsibility for deserializing/describing journal events, but the return types (IEventSequence vs IEventSequence) and the context (upcasting vs reading) are slightly different. The naming 'FromJournal' is used in both, but one is for upcasting and one is for reading, which might be confusing.
• Bounded contexts not declared
• Duplicated block (10 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (10 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (12 lines × 2) (src/Akkatecture/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (13 lines × 2) (src/Akkatecture/Jobs/JobRunner.cs)
• Duplicated block (13 lines × 2) (src/Akkatecture/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (13 lines × 3) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (6 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (7 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (7 lines × 2) (src/Akkatecture/Query/Consumer.cs)
• Duplicated block (7 lines × 2) (src/Akkatecture/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (9 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Inconsistent naming for event emission. One method is named 'Emit' (singular) and the other 'EmitAll' (plural). While distinct in arity, the naming convention for the singular case ('Emit') vs the plural case ('EmitAll') is slightly inconsistent with common patterns like 'Emit' and 'EmitBatch' or 'EmitRange'. However, the primary inconsistency is that 'Emit' takes a generic type parameter and a specific event, while 'EmitAll' takes an array of the interface. A more consistent API might use 'Emit' for single and 'EmitMany' or 'EmitBatch' for multiple, or ensure the naming convention is parallel.
• Inconsistent parameter types for result creation. 'SucceedWith' accepts either an ICommand or a string (commandId). 'FailWith' accepts either an ICommand or a string (commandId). This creates two different ways to create success/failure states, which can be confusing. It is unclear if passing the command object is preferred over the ID.
• LLM evaluation failed
• Largest orphaned file (src/Akkatecture/Aggregates/AggregateRoot.cs)
• …and 10 more

• Assertions commented out: TestDistinctCommand_AfterTwoHandles_CommandFails (test/Akkatecture.Tests/UnitTests/Aggregates/AggregateTests.cs)
• CommentedOutCode (test/Akkatecture.Tests/UnitTests/Aggregates/AggregateTests.cs)
• CommentedOutCode (test/Akkatecture.Tests/UnitTests/Aggregates/AggregateTestsWithFixtures.cs)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicate method signature with different return type handling in non-generic interface
• Duplicated block (11 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (11 lines × 8) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (12 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (13–14 lines × 3) (src/Akkatecture/Sagas/AggregateSaga/AggregateSaga.cs)
• Duplicated block (13–14 lines × 5) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (13–15 lines × 4) (src/Akkatecture.Clustering/Extentions/TypeExtensions.cs)
• Duplicated block (15 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (15–18 lines × 5) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (15–19 lines × 3) (src/Akkatecture/Jobs/JobRunner.cs)
• Duplicated block (17 lines × 2) (src/Akkatecture/Extensions/TypeExtensions.cs)
• Duplicated block (20 lines × 2) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (20–21 lines × 3) (src/Akkatecture/Aggregates/AggregateRoot.cs)
• Duplicated block (21–22 lines × 2) (src/Akkatecture/Jobs/JobRunner.cs)
• …and 42 more

• Unchanged — 5 HTTP endpoints

• Unchanged — 0 containers · 2 contexts · 1 edges

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

AfterLutz/Akkatecture 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.