Baseline Feature (#10)

* Add baseline comparison functionality for cognitive metrics

- Introduced new classes for baseline comparison, including `BaselineComparer`, `BaselineLoader`, and `BaselineSnapshotFactory`.
- Implemented methods to compare current cognitive metrics against baseline snapshots, allowing for detailed analysis of changes over time.
- Added support for serializing and deserializing baseline snapshots using JSON.
- Enhanced existing reports (CSV, HTML, GitHub Actions, and GitLab) to include baseline comparison data, providing richer insights into cognitive metrics.
- Updated `CognitiveCiSeverity` and report formatting classes to accommodate new baseline comparison features.
- Added tests to validate baseline comparison logic and report generation with baseline data.

* Update README to include new report types and options for baseline comparison

- Added `Json` and `Csv` as new report types for cognitive analysis.
- Introduced `-b|--baseline <path>` option for comparing current metrics against a JSON baseline snapshot.
- Included `--show-coupling` option to enable class coupling metrics in the analysis.
- Updated examples to demonstrate the usage of new options and report types.

* Add default cognitive configuration and update configuration loading

- Introduced `CognitiveConfigurationDefaults` class to provide a standard set of default values for cognitive analysis configuration.
- Updated `ConfigurationLoader` to utilize the new defaults when creating a `CognitiveConfiguration` instance.
- Added unit test to verify that the default configuration matches expected values.
- Modified project file to include `cognitive-metrics-settings.json` for output directory preservation.

* Refactor cognitive analysis methods and enhance baseline comparison functionality

- Updated `GetFullSignature` method in `CognitiveCodeAnalyser` to include type parameters and constraints in method signatures.
- Refactored `BaselineComparer` to utilize a new `ToDictionaryLastWins` method for improved dictionary creation.
- Changed access modifiers of methods in `BaselineMethodKey` from internal to public for broader accessibility.
- Added unit tests in `BaselineDuplicateKeyTests` to ensure proper handling of duplicate method keys and class names across different namespaces.

Author: floriankraemer

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/Baseline/BaselineComparerTests.cs

@@ -0,0 +1,118 @@
+/// <copyright company="Florian Krämer">
+///     Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/// </copyright>
+
+using CognitiveCodeAnalysis.CognitiveAnalysis;
+using CognitiveCodeAnalysis.CognitiveAnalysis.Baseline;
+using CognitiveCodeAnalysis.CouplingAnalysis;
+
+namespace CognitiveCodeAnalysis.Tests.CognitiveAnalysis.Baseline;
+
+public class BaselineComparerTests
+{
+    [Test]
+    public void Compare_ComputesDeltaForMatchedMethod()
+    {
+        var baselineMetrics = SampleMetric(totalScore: 2.0, ifCount: 1);
+        var currentMetrics = SampleMetric(totalScore: 2.5, ifCount: 3);
+
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection { baselineMetrics });
+        var current = new CognitiveMetricsCollection { currentMetrics };
+
+        var comparison = BaselineComparer.Compare(current, baseline);
+
+        Assert.That(comparison.TryGetMethodComparison(currentMetrics, out MethodMetricsComparison? methodComparison), Is.True);
+        Assert.That(methodComparison!.TotalScore.Delta, Is.EqualTo(0.5).Within(0.0001));
+        Assert.That(methodComparison.IfCount.Delta, Is.EqualTo(2));
+    }
+
+    [Test]
+    public void Compare_NewMethod_HasNoBaselineDelta()
+    {
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection());
+        var currentMetrics = SampleMetric(totalScore: 1.0, ifCount: 0);
+        var current = new CognitiveMetricsCollection { currentMetrics };
+
+        var comparison = BaselineComparer.Compare(current, baseline);
+
+        Assert.That(comparison.TryGetMethodComparison(currentMetrics, out MethodMetricsComparison? methodComparison), Is.True);
+        Assert.That(methodComparison!.HasBaseline, Is.False);
+        Assert.That(methodComparison.TotalScore.Delta, Is.Null);
+    }
+
+    [Test]
+    public void Compare_MatchesByNormalizedPathAndSignature()
+    {
+        var baselineMetrics = SampleMetric(totalScore: 1.0, ifCount: 0);
+        baselineMetrics.FilePath = @"src\Demo.cs";
+
+        var currentMetrics = SampleMetric(totalScore: 2.0, ifCount: 1);
+        currentMetrics.FilePath = "src/Demo.cs";
+        currentMetrics.methodLineNumber = 99;
+
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection { baselineMetrics });
+        var current = new CognitiveMetricsCollection { currentMetrics };
+
+        var comparison = BaselineComparer.Compare(current, baseline);
+
+        Assert.That(comparison.TryGetMethodComparison(currentMetrics, out MethodMetricsComparison? methodComparison), Is.True);
+        Assert.That(methodComparison!.HasBaseline, Is.True);
+        Assert.That(methodComparison.TotalScore.Delta, Is.EqualTo(1.0).Within(0.0001));
+    }
+
+    [Test]
+    public void Compare_NullableCoverageDelta_OnlyWhenBothSidesHaveValues()
+    {
+        var baselineMetrics = SampleMetric(totalScore: 1.0, ifCount: 0);
+        baselineMetrics.lineCoveragePercentage = 50.0;
+
+        var currentWithCoverage = SampleMetric(totalScore: 1.0, ifCount: 0);
+        currentWithCoverage.lineCoveragePercentage = 80.0;
+
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection { baselineMetrics });
+        var current = new CognitiveMetricsCollection { currentWithCoverage };
+
+        var comparison = BaselineComparer.Compare(current, baseline);
+
+        Assert.That(comparison.TryGetMethodComparison(currentWithCoverage, out MethodMetricsComparison? methodComparison), Is.True);
+        Assert.That(methodComparison!.LineCoveragePercentage.Delta, Is.EqualTo(30.0).Within(0.0001));
+    }
+
+    [Test]
+    public void Compare_ClassCouplingDelta()
+    {
+        var metrics = SampleMetric(totalScore: 1.0, ifCount: 0);
+        var current = new CognitiveMetricsCollection { metrics };
+        current.SetClassCouplingMetrics(
+        [
+            new ClassCouplingMetrics { ClassName = "C", IncomingCoupling = 3, OutgoingCoupling = 2, Stability = 0.4 },
+        ]);
+
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(current);
+        current.SetClassCouplingMetrics(
+        [
+            new ClassCouplingMetrics { ClassName = "C", IncomingCoupling = 5, OutgoingCoupling = 1, Stability = 0.2 },
+        ]);
+
+        var comparison = BaselineComparer.Compare(current, baseline);
+
+        Assert.That(comparison.TryGetClassCouplingComparison("C", out ClassCouplingComparison? couplingComparison), Is.True);
+        Assert.That(couplingComparison!.IncomingCoupling.Delta, Is.EqualTo(2));
+        Assert.That(couplingComparison.OutgoingCoupling.Delta, Is.EqualTo(-1));
+        Assert.That(couplingComparison.Stability.Delta, Is.EqualTo(-0.2).Within(0.0001));
+    }
+
+    private static CognitiveMetrics SampleMetric(double totalScore, int ifCount)
+    {
+        var m = new CognitiveMetrics(
+            methodName: "Foo",
+            className: "C",
+            filePath: "src/Demo.cs",
+            methodSignature: "void Foo()",
+            methodLineNumber: 10,
+            ifCount: ifCount
+        );
+        m.totalScore = totalScore;
+        return m;
+    }
+}

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/Baseline/BaselineDuplicateKeyTests.cs

@@ -0,0 +1,82 @@
+/// <copyright company="Florian Krämer">
+///     Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/// </copyright>
+
+using CognitiveCodeAnalysis.CognitiveAnalysis;
+using CognitiveCodeAnalysis.CognitiveAnalysis.Baseline;
+using CognitiveCodeAnalysis.Configuration;
+
+namespace CognitiveCodeAnalysis.Tests.CognitiveAnalysis.Baseline;
+
+public class BaselineDuplicateKeyTests
+{
+    private CognitiveCodeAnalyser _analyser = null!;
+    private CognitiveConfiguration _configuration = null!;
+    private TempFiles _tempFiles = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _analyser = new CognitiveCodeAnalyser();
+        _configuration = CognitiveConfigurationDefaults.Create();
+        _tempFiles = new TempFiles();
+    }
+
+    [TearDown]
+    public void TearDown() => _tempFiles.CleanUp();
+
+    [Test]
+    public void Compare_WithGenericConstraintOverloads_DoesNotThrow()
+    {
+        _tempFiles.CreateFileWithContent(
+            "Generic.cs",
+            """
+            namespace DupTest;
+            public class GenericOverload
+            {
+                public void Foo<T>(T t) where T : class { }
+                public void Foo<T>(T t) where T : struct { }
+            }
+            """
+        );
+
+        var files = Directory.GetFiles(_tempFiles.tmpDirectory, "*.cs").ToList();
+        var metrics = _analyser.AnalyseFilesAsync(files, _configuration).GetAwaiter().GetResult();
+        var snapshot = BaselineSnapshotFactory.FromMetricsCollection(metrics);
+
+        Assert.DoesNotThrow(() => BaselineComparer.Compare(metrics, snapshot));
+
+        var duplicateKeys = metrics
+            .GroupBy(BaselineMethodKey.FromMetrics)
+            .Where(g => g.Count() > 1)
+            .ToList();
+
+        Assert.That(duplicateKeys, Is.Empty);
+    }
+
+    [Test]
+    public void Compare_WithSameClassNameInDifferentNamespaces_DoesNotThrow()
+    {
+        _tempFiles.CreateFileWithContent(
+            "Worker1.cs",
+            """
+            namespace NamespaceA;
+            public class Worker { public void A() { } }
+            """
+        );
+        _tempFiles.CreateFileWithContent(
+            "Worker2.cs",
+            """
+            namespace NamespaceB;
+            public class Worker { public void B() { } }
+            """
+        );
+
+        var files = Directory.GetFiles(_tempFiles.tmpDirectory, "*.cs").ToList();
+        var metrics = _analyser.AnalyseFilesAsync(files, _configuration).GetAwaiter().GetResult();
+        var snapshot = BaselineSnapshotFactory.FromMetricsCollection(metrics);
+
+        Assert.DoesNotThrow(() => BaselineComparer.Compare(metrics, snapshot));
+        Assert.That(metrics.Select(m => m.ClassName).Distinct().Count(), Is.EqualTo(2));
+    }
+}

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/Baseline/BaselineLoaderTests.cs

@@ -0,0 +1,70 @@
+/// <copyright company="Florian Krämer">
+///     Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/// </copyright>
+
+using CognitiveCodeAnalysis.CognitiveAnalysis;
+using CognitiveCodeAnalysis.CognitiveAnalysis.Baseline;
+
+namespace CognitiveCodeAnalysis.Tests.CognitiveAnalysis.Baseline;
+
+public class BaselineLoaderTests
+{
+    [Test]
+    public void RoundTrip_SerializesAndDeserializesSnapshot()
+    {
+        var metrics = new CognitiveMetrics(
+            methodName: "Alpha",
+            className: "Demo",
+            filePath: "src/Demo.cs",
+            methodSignature: "void Alpha()",
+            methodLineNumber: 10
+        );
+        metrics.totalScore = 2.5;
+
+        var snapshot = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection { metrics });
+        var path = Path.Combine(Path.GetTempPath(), "baseline-" + Guid.NewGuid() + ".json");
+
+        try
+        {
+            File.WriteAllText(path, BaselineLoader.Serialize(snapshot));
+            var loaded = BaselineLoader.Load(path);
+
+            Assert.That(loaded.SchemaVersion, Is.EqualTo(CognitiveBaselineSnapshot.CurrentSchemaVersion));
+            Assert.That(loaded.Methods, Has.Count.EqualTo(1));
+            Assert.That(loaded.Methods[0].MethodName, Is.EqualTo("Alpha"));
+            Assert.That(loaded.Methods[0].TotalScore, Is.EqualTo(2.5).Within(0.0001));
+        }
+        finally
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+    }
+
+    [Test]
+    public void Load_ThrowsForUnsupportedSchemaVersion()
+    {
+        var path = Path.Combine(Path.GetTempPath(), "baseline-bad-" + Guid.NewGuid() + ".json");
+
+        try
+        {
+            File.WriteAllText(path, """{"schemaVersion":99,"generatedAt":"2026-01-01T00:00:00Z","methods":[],"classCoupling":[]}""");
+            Assert.Throws<InvalidOperationException>(() => BaselineLoader.Load(path));
+        }
+        finally
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+    }
+
+    [Test]
+    public void Load_ThrowsWhenFileMissing()
+    {
+        Assert.Throws<FileNotFoundException>(() => BaselineLoader.Load(Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".json")));
+    }
+}

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/Baseline/CognitiveReportDeltaFormatterTests.cs

@@ -0,0 +1,64 @@
+/// <copyright company="Florian Krämer">
+///     Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/// </copyright>
+
+using CognitiveCodeAnalysis.CognitiveAnalysis.Baseline;
+using CognitiveCodeAnalysis.CognitiveAnalysis.Reports;
+
+namespace CognitiveCodeAnalysis.Tests.CognitiveAnalysis.Baseline;
+
+public class CognitiveReportDeltaFormatterTests
+{
+    [Test]
+    public void FormatHtmlDeltaSuffix_Up_IsRedWithTriangle()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 2.5, Delta = 0.5 };
+        var suffix = CognitiveReportDeltaFormatter.FormatHtmlDeltaSuffix(delta, "F3");
+
+        Assert.That(suffix, Does.Contain("delta-up"));
+        Assert.That(suffix, Does.Contain("▲0.500"));
+    }
+
+    [Test]
+    public void FormatHtmlDeltaSuffix_Down_IsGreenWithTriangle()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 1.5, Delta = -0.5 };
+        var suffix = CognitiveReportDeltaFormatter.FormatHtmlDeltaSuffix(delta, "F3");
+
+        Assert.That(suffix, Does.Contain("delta-down"));
+        Assert.That(suffix, Does.Contain("▼0.500"));
+    }
+
+    [Test]
+    public void FormatHtmlDeltaSuffix_Zero_IsEmpty()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 2.0, Delta = 0.0 };
+        Assert.That(CognitiveReportDeltaFormatter.FormatHtmlDeltaSuffix(delta, "F3"), Is.Empty);
+    }
+
+    [Test]
+    public void FormatConsoleDeltaSuffix_Up_IsRedMarkup()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 3.0, Delta = 1.0 };
+        var suffix = CognitiveReportDeltaFormatter.FormatConsoleDeltaSuffix(delta, "F3");
+
+        Assert.That(suffix, Does.Contain("[red]"));
+        Assert.That(suffix, Does.Contain("▲1.000"));
+    }
+
+    [Test]
+    public void FormatCiSuffix_IncludesBaselineText()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 2.5, Delta = 0.5 };
+        var suffix = CognitiveReportDeltaFormatter.FormatCiSuffix(delta, "F3");
+
+        Assert.That(suffix, Is.EqualTo(" (▲0.500 vs baseline)"));
+    }
+
+    [Test]
+    public void FormatCsvDelta_ReturnsSignedValue()
+    {
+        var delta = new MetricDelta { BaselineValue = 2.0, CurrentValue = 2.5, Delta = 0.5 };
+        Assert.That(CognitiveReportDeltaFormatter.FormatCsvDelta(delta, "F3"), Is.EqualTo("0.500"));
+    }
+}

CognitiveCodeAnalysis.Tests/src/CognitiveAnalysis/Reports/HtmlReportGoldenTests.cs

@@ -3,6 +3,7 @@
 /// </copyright>
 
 using CognitiveCodeAnalysis.CognitiveAnalysis;
+using CognitiveCodeAnalysis.CognitiveAnalysis.Baseline;
 using CognitiveCodeAnalysis.CognitiveAnalysis.Reports;
 using CognitiveCodeAnalysis.Configuration;
 
@@ -61,4 +62,49 @@ public void HtmlReport_RendersStableTitleAndMethodRow()
             }
         }
     }
+
+    [Test]
+    public void HtmlReport_WithBaseline_ShowsColoredDeltaSuffixes()
+    {
+        var baselineMetrics = new CognitiveMetrics(
+            methodName: "Alpha",
+            className: "Demo",
+            filePath: "src/Demo.cs",
+            methodSignature: "void Alpha()",
+            methodLineNumber: 10
+        );
+        baselineMetrics.totalScore = 2.0;
+
+        var currentMetrics = new CognitiveMetrics(
+            methodName: "Alpha",
+            className: "Demo",
+            filePath: "src/Demo.cs",
+            methodSignature: "void Alpha()",
+            methodLineNumber: 10
+        );
+        currentMetrics.totalScore = 2.5;
+
+        var baseline = BaselineSnapshotFactory.FromMetricsCollection(new CognitiveMetricsCollection { baselineMetrics });
+        var current = new CognitiveMetricsCollection { currentMetrics };
+        var comparison = BaselineComparer.Compare(current, baseline);
+        var config = new CognitiveConfiguration { GroupByClass = false, ShowOnlyMethodsExceedingThreshold = false };
+
+        var path = Path.Combine(Path.GetTempPath(), "html-baseline-" + Guid.NewGuid() + ".html");
+        try
+        {
+            new HtmlReport().RenderMetrics(path, current, config, comparison);
+            var html = File.ReadAllText(path);
+
+            Assert.That(html, Does.Contain("delta-up"));
+            Assert.That(html, Does.Contain("▲0.500"));
+            Assert.That(html, Does.Contain("2.500"));
+        }
+        finally
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+    }
 }