cbcrouse/Versioning.NET

Versioning.NET is a .NET console application that automates semantic versioning for .NET projects by integrating with Git repositories. It provides commands to increment assembly versions, generate Git tags, and parse commit messages to determine version increments. The system supports beta mode adjustments and custom tag formatting, all managed through a clean architecture with MediatR and FluentValidation.

24 changes.

This period focused on implementing automated versioning and Git integration features within a Clean Architecture structure. The work involved building services for assembly and Git versioning, defining domain entities and interfaces, and adding comprehensive test coverage for these new capabilities.

4 changes.

This period focused on modernizing the application's architecture by introducing a new .NET console application for versioning operations and refactoring service registration to use a composition pipeline. The work also included adding unit tests and validators to support these structural changes.

New files were added to the Common library to integrate AutoFixture for generating test data. This includes an AutoFixtureFactory for creating customized IFixture instances, a TypeExtensions helper, and an AutoFixtureAttribute for xUnit.net theories, enabling automatic generation of test specimens.

src/Common · high confidence

A new handler, IncrementAssemblyVersionHandler, was added to process the IncrementAssemblyVersionCommand. It retrieves the latest assembly version and applies version increments, with specific logic to handle beta states: it lowers the increment when in beta mode and switches to a major version increment when exiting beta.

src/Application/AssemblyVersioning/Handlers · medium confidence

A new InfrastructureOptions class has been introduced in the infrastructure layer to provide configuration values for that layer.

src/Infrastructure/Configuration · high confidence

The MediatR infrastructure layer now includes three new pipeline behaviors: a request logger that logs incoming requests at the debug level, a metrics behavior that logs warnings for requests exceeding 500ms, and a validation behavior that throws exceptions for invalid requests using FluentValidation.

src/Infrastructure/MediatR · high confidence

A new IValidatable marker interface and an ApplicationOptions class have been introduced in the Application layer to enforce validation for configuration values.

src/Application/Configuration · medium confidence

Introduced new domain entities to support Git integration and versioning logic. This includes \GitCommit\ and \GitCommitFileInfo\ to represent commit records and their associated file changes, \GitCommitFilter\ for querying commits by hash ranges and sort mode, and \GitCommitVersionInfo\ to parse commit messages (e.g., Angular-style headers) and determine version increments (Major, Minor, Patch, or None) based on commit types and special markers like \\[exit beta\]\ or \\#breaking\. Additionally, \VersionIncrement\ and \GitCommitSortMode\ enumerations were added to support these features.

src/Domain/Entities · high confidence

A new static class, RegexPatterns, has been introduced in the Domain.Constants namespace to centralize regular expressions used for parsing git log lines. It provides two specific patterns: one to match the 7+ character commit ID at the start of a line, and another to match the commit message subject, which includes the type, scope, and subject text. This change supports the versioning and commit analysis features by providing standardized, reusable regex definitions.

src/Domain/Constants · high confidence

A new extension class for Git commits has been added to the infrastructure layer, providing methods to retrieve file updates associated with a commit and to convert a Git commit object into a domain model. This change introduces a new public API for inspecting commit metadata and mapping it to the application's domain entities.

src/Infrastructure/Extensions · medium confidence

The Versioning.NET project now provides a new command-line interface for managing project versions. Users can increment versions in csproj files, with options for standard updates, Git-integrated updates, and commit-message-based updates. The application is built on .NET 10.0 and utilizes MediatR for command handling, with a new AppServiceComposition for startup orchestration.

src/Versioning.NET · high confidence

Added new services for managing assembly versions and Git-based versioning. The \AssemblyVersioningService\ scans directories for \.csproj\ files to read and increment semantic versions (Major, Minor, Patch) while preserving XML whitespace. The \GitVersioningService\ extracts version hints from Git tags and commit messages, determining the priority of version increments. Additionally, a \LibGit2Service\ was introduced to handle Git operations (commits, tags, pushes) using the LibGit2Sharp library, replacing previous PowerShell-based integrations. These changes enable automated versioning workflows that combine local assembly updates with Git tag creation and remote pushes.

src/Infrastructure/Services · high confidence

Added two new extension classes in the Application layer: GitCommitExtensions provides a method to parse version information from Git commit subjects using a regex pattern, and VersionIncrementExtensions introduces a ToBeta method that downgrades a Major version increment to Minor when in beta mode.

src/Application/Extensions · high confidence

A new IncrementAssemblyVersionCommand has been added to the application layer. This command allows users to increment assembly versions by specifying a target directory, a search option for nested files, and a version increment strategy. It also supports an option to exit beta mode during the versioning process.

src/Application/AssemblyVersioning/Commands · high confidence

Three new interfaces are introduced in the Application layer to support automated versioning and Git integration. IAssemblyVersioningService provides methods to retrieve the latest assembly version from a directory and to increment that version. IGitService abstracts Git operations such as retrieving commits and tags, creating commits, and pushing to a remote. IGitVersioningService handles retrieving version hints from Git commit messages and determining version increments. These interfaces enable the application to manage assembly versions and interact with Git repositories in a testable way.

src/Application/Interfaces · high confidence

The repository now includes the full solution structure for the Versioning.NET project, organizing code into src (Application, Domain, Infrastructure, Events, Common, Versioning.NET) and tst (Common.Tests, Business.Tests, Infrastructure.Tests, Versioning.NET.Tests, Integration.Tests) projects. The README has been expanded with comprehensive documentation on the tool's objective, architecture (Clean Architecture), branching strategies (Git Flow, GitHub Flow), and usage instructions. Additionally, the .gitignore file was updated to exclude iOS files, local appsettings, and Azure Functions local settings.

(repo-wide) · high confidence

The \IncrementVersionWithGitCommand\ and \IncrementVersionWithGitHintsCommand\ have been updated to include new properties: \TagPrefix\ (defaulting to 'v'), \TagSuffix\, \ExitBeta\, and \TargetDirectory\. This allows users to customize how version tags are formatted in Git and to explicitly exit beta mode during version increments. The corresponding handlers (\IncrementVersionWithGitHandler\ and \IncrementVersionWithGitHintsHandler\) have been refactored to utilize these new properties when creating Git tags and processing version increments.

src/Application/GitVersioning · high confidence

The application's service registration has been refactored to use the ServiceComposition.NET library, which provides a new \CoreServiceRegistrationPipeline\ class for registering MediatR, FluentValidation, and various application services. This change replaces the previous manual registration approach, streamlining how dependencies like MediatR behaviors and validators are added to the service container.

src/Infrastructure/Startup · medium confidence

A new validator has been introduced for the IncrementAssemblyVersionCommand, ensuring that the specified directory exists and that the version increment is not set to an unknown state.

src/Application/AssemblyVersioning/Validators · medium confidence

Added integration tests for Git and AssemblyVersioning services; Added startup and service registration tests for versioning and Git integration; Added test coverage for Git versioning commands and handlers; Added test for IncrementVersionWithGitHintsHandler; Added test setup helpers for Git and service provider initialization; Added tests for Git versioning service; Added tests for TypeExtensions.HasEmptyConstructor; Added tests for assembly versioning logic; Added unit tests for GitCommit and GitCommitFilter entities; Added unit tests for regex pattern matching and version increment logic.

The project has been upgraded to target .NET 10.0 across all source and test projects. This includes updating the .NET SDK and related packages such as Microsoft.Extensions.Hosting, Microsoft.Extensions.Logging, and xunit to their latest compatible versions. Additionally, the Infrastructure layer now references LibGit2Sharp and ServiceComposition.NET, while the Versioning.NET tooling relies on McMaster.Extensions.CommandLineUtils. These changes ensure the application and its components are built on the latest .NET runtime and updated third-party libraries.

(dependencies) · high confidence

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

• CAI 55 → 54 (-1.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 66 (-12.5)
• Architecture 90 → 90 (+0.1)
• Maturity 48 → 43 (-5.1)
• Readiness 61 → 60 (-1.3)
• Security 58 → 74 (+16.4)
• Performance 60 → 60 (+0.0)

• BarePragmaDisable (src/Versioning.NET/Program.cs)
• Bounded contexts not declared
• Change coupling: IncrementVersion.cs ↔ IncrementVersionWithGit.cs (src/Versioning.NET/Commands/IncrementVersion.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• …and 4 more

• CRAP 56: AutoFixtureFactory.GetInstance (src/Common/AutoFixture/AutoFixtureFactory.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (35 lines × 2) (src/Application/GitVersioning/Handlers/IncrementVersionWithGitHandler.cs)
• Duplicated block (36 lines × 2) (src/Application/GitVersioning/Commands/IncrementVersionWithGitCommand.cs)
• Duplicated block (40 lines × 2) (src/Versioning.NET/Commands/IncrementVersionWithGit.cs)
• FileScopedPragmaDisable (src/Versioning.NET/Program.cs)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 23 more

• Unchanged — 1 containers · 0 contexts · 0 edges

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

cbcrouse/Versioning.NET 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.