Merge pull request #476 from FritzAndFriends/dev

fix: Dashboard health scores use pre-computed snapshots in Docker

Author: csharpfritz

samples/AfterBlazorServerSide/Dockerfile

@@ -12,7 +12,9 @@ COPY ["Directory.Build.props", "./"]
 COPY ["samples/AfterBlazorServerSide/AfterBlazorServerSide.csproj", "samples/AfterBlazorServerSide/"]
 COPY ["src/BlazorWebFormsComponents/BlazorWebFormsComponents.csproj", "src/BlazorWebFormsComponents/"]
 COPY ["samples/SharedSampleObjects/SharedSampleObjects.csproj", "samples/SharedSampleObjects/"]
+COPY ["scripts/GenerateHealthSnapshot/GenerateHealthSnapshot.csproj", "scripts/GenerateHealthSnapshot/"]
 RUN dotnet restore "samples/AfterBlazorServerSide/AfterBlazorServerSide.csproj"
+RUN dotnet restore "scripts/GenerateHealthSnapshot/GenerateHealthSnapshot.csproj"
 COPY . .
 # Remove NBGV - not functional in Docker without .git; version is injected via VERSION build arg
 RUN sed -i '/<PackageReference Include="Nerdbank.GitVersioning"/,/<\/PackageReference>/d' Directory.Build.props
@@ -21,6 +23,8 @@ RUN dotnet build "AfterBlazorServerSide.csproj" -c Release -o /app/build -p:Vers
 
 FROM build AS publish
 RUN dotnet publish "AfterBlazorServerSide.csproj" -c Release -o /app/publish -p:Version=$VERSION -p:InformationalVersion=$VERSION
+# Generate health snapshot while the full repo is still available in /src
+RUN dotnet run --project /src/scripts/GenerateHealthSnapshot/GenerateHealthSnapshot.csproj -- /src /app/publish/health-snapshot.json
 
 FROM base AS final
 WORKDIR /app

scripts/Generate-HealthSnapshot.ps1

@@ -0,0 +1,45 @@
+<#
+.SYNOPSIS
+    Generates a health-snapshot.json file containing pre-computed Component Health Dashboard data.
+
+.DESCRIPTION
+    Builds and runs the GenerateHealthSnapshot console tool, which performs live reflection
+    and file scanning against the repository to produce a JSON snapshot of all component
+    health reports. This snapshot can be bundled with published apps so the dashboard
+    works in environments where the repo filesystem is not available (e.g., Docker).
+
+.PARAMETER OutputPath
+    Path to write the snapshot file. Defaults to the repo root's health-snapshot.json.
+
+.EXAMPLE
+    .\Generate-HealthSnapshot.ps1
+    .\Generate-HealthSnapshot.ps1 -OutputPath ./publish/health-snapshot.json
+#>
+param(
+    [string]$OutputPath
+)
+
+$ErrorActionPreference = 'Stop'
+
+$repoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..')).Path
+$projectPath = Join-Path $PSScriptRoot 'GenerateHealthSnapshot' 'GenerateHealthSnapshot.csproj'
+
+if (-not $OutputPath) {
+    $OutputPath = Join-Path $repoRoot 'health-snapshot.json'
+}
+
+Write-Host "Building snapshot generator..." -ForegroundColor Cyan
+dotnet build $projectPath -c Release --nologo -v quiet
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Build failed."
+    exit 1
+}
+
+Write-Host "Generating health snapshot..." -ForegroundColor Cyan
+dotnet run --project $projectPath -c Release --no-build -- $repoRoot $OutputPath
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Snapshot generation failed."
+    exit 1
+}
+
+Write-Host "Health snapshot written to: $OutputPath" -ForegroundColor Green

scripts/GenerateHealthSnapshot/GenerateHealthSnapshot.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <!-- Exclude from NBGV versioning to keep this tool simple -->
+    <NerdbankGitVersioningEnabled>false</NerdbankGitVersioningEnabled>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\BlazorWebFormsComponents\BlazorWebFormsComponents.csproj" />
+  </ItemGroup>
+
+</Project>

scripts/GenerateHealthSnapshot/Program.cs

@@ -0,0 +1,26 @@
+using BlazorWebFormsComponents.Diagnostics;
+
+if (args.Length < 2)
+{
+	Console.Error.WriteLine("Usage: GenerateHealthSnapshot <solutionRoot> <outputPath>");
+	Console.Error.WriteLine("  solutionRoot: Path to the repository root");
+	Console.Error.WriteLine("  outputPath:   Path to write health-snapshot.json");
+	return 1;
+}
+
+var solutionRoot = args[0];
+var outputPath = args[1];
+
+Console.WriteLine($"Solution root: {solutionRoot}");
+Console.WriteLine($"Output path:   {outputPath}");
+
+var baselinesPath = Path.Combine(solutionRoot, "dev-docs", "reference-baselines.json");
+var baselines = ReferenceBaselines.LoadFromFile(baselinesPath);
+var service = new ComponentHealthService(baselines, solutionRoot);
+
+HealthSnapshotGenerator.GenerateSnapshot(service, outputPath);
+
+var reports = service.GetAllReports();
+Console.WriteLine($"Generated snapshot with {reports.Count} component reports.");
+
+return 0;

src/BlazorWebFormsComponents/Diagnostics/ComponentHealthService.cs

@@ -11,11 +11,14 @@ namespace BlazorWebFormsComponents.Diagnostics
 	/// <summary>
 	/// Analyzes BWFC components via reflection and file scanning to produce health reports
 	/// measuring how completely each Blazor component reproduces its Web Forms original.
+	/// When the repository filesystem is not available (e.g., in Docker), the service can
+	/// serve pre-computed reports from a snapshot JSON file.
 	/// </summary>
 	public class ComponentHealthService
 	{
 		private readonly ReferenceBaselines _baselines;
 		private readonly string _solutionRoot;
+		private readonly IReadOnlyList<ComponentHealthReport> _snapshotReports;
 
 		private static readonly HashSet<Type> StopTypes = new HashSet<Type>
 		{
@@ -25,6 +28,12 @@ public class ComponentHealthService
 			typeof(DataBoundComponent<>)
 		};
 
+		/// <summary>
+		/// Returns true when this instance is serving pre-computed snapshot data
+		/// rather than live reflection/file-scanning results.
+		/// </summary>
+		public bool IsFromSnapshot => _snapshotReports != null;
+
 		// Hardcoded fallback per PRD §3.3 — used when dev-docs/tracked-components.json doesn't exist
 		private static readonly Dictionary<string, TrackedComponent> DefaultTrackedComponents = new Dictionary<string, TrackedComponent>(StringComparer.OrdinalIgnoreCase)
 		{
@@ -111,23 +120,42 @@ public class ComponentHealthService
 		private Dictionary<string, Type> _discoveredTypes;
 
 		/// <summary>
-		/// Creates a new ComponentHealthService.
+		/// Creates a new ComponentHealthService that performs live reflection and file scanning.
 		/// </summary>
 		/// <param name="baselines">Reference baselines loaded from JSON.</param>
 		/// <param name="solutionRoot">Path to the repository root (for file scanning).</param>
 		public ComponentHealthService(ReferenceBaselines baselines, string solutionRoot)
 		{
 			_baselines = baselines ?? new ReferenceBaselines();
 			_solutionRoot = solutionRoot ?? "";
+			_snapshotReports = null;
 			_trackedComponents = LoadTrackedComponents();
 			_discoveredTypes = DiscoverComponentTypes();
 		}
 
+		/// <summary>
+		/// Creates a ComponentHealthService that serves pre-computed snapshot data.
+		/// Used in environments where the repository filesystem is not available.
+		/// </summary>
+		/// <param name="snapshotReports">Pre-computed health reports loaded from a snapshot file.</param>
+		internal ComponentHealthService(IReadOnlyList<ComponentHealthReport> snapshotReports)
+		{
+			_snapshotReports = snapshotReports ?? throw new ArgumentNullException(nameof(snapshotReports));
+			_baselines = new ReferenceBaselines();
+			_solutionRoot = "";
+			_trackedComponents = new Dictionary<string, TrackedComponent>(StringComparer.OrdinalIgnoreCase);
+			_discoveredTypes = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
+		}
+
 		/// <summary>
 		/// Gets health reports for all tracked components.
+		/// When running from a snapshot, returns the pre-computed reports.
 		/// </summary>
 		public IReadOnlyList<ComponentHealthReport> GetAllReports()
 		{
+			if (_snapshotReports != null)
+				return _snapshotReports;
+
 			var reports = new List<ComponentHealthReport>();
 			foreach (var kvp in _trackedComponents.OrderBy(k => k.Value.Category).ThenBy(k => k.Key))
 			{
@@ -142,6 +170,9 @@ public IReadOnlyList<ComponentHealthReport> GetAllReports()
 		/// </summary>
 		public ComponentHealthReport GetReport(string componentName)
 		{
+			if (_snapshotReports != null)
+				return _snapshotReports.FirstOrDefault(r => r.Name.Equals(componentName, StringComparison.OrdinalIgnoreCase));
+
 			if (!_trackedComponents.TryGetValue(componentName, out var tracked))
 				return null;
 			return BuildReport(componentName, tracked);

src/BlazorWebFormsComponents/Diagnostics/HealthSnapshotGenerator.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace BlazorWebFormsComponents.Diagnostics
+{
+	/// <summary>
+	/// Generates and loads pre-computed health report snapshots.
+	/// Used to provide accurate health data in environments (e.g., Docker containers)
+	/// where the repository filesystem is not available.
+	/// </summary>
+	public static class HealthSnapshotGenerator
+	{
+		/// <summary>
+		/// The default filename for the health snapshot JSON file.
+		/// </summary>
+		public const string SnapshotFileName = "health-snapshot.json";
+
+		private static readonly JsonSerializerOptions SerializerOptions = new JsonSerializerOptions
+		{
+			WriteIndented = true,
+			PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+			Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) }
+		};
+
+		/// <summary>
+		/// Generates a health snapshot JSON file from the given service.
+		/// </summary>
+		/// <param name="service">The health service to snapshot.</param>
+		/// <param name="outputPath">Full path to write the JSON file.</param>
+		public static void GenerateSnapshot(ComponentHealthService service, string outputPath)
+		{
+			var reports = service.GetAllReports();
+			var json = JsonSerializer.Serialize(reports, SerializerOptions);
+			var dir = Path.GetDirectoryName(outputPath);
+			if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+			{
+				Directory.CreateDirectory(dir);
+			}
+			File.WriteAllText(outputPath, json);
+		}
+
+		/// <summary>
+		/// Loads pre-computed health reports from a snapshot JSON file.
+		/// Returns null if the file does not exist or cannot be parsed.
+		/// </summary>
+		/// <param name="snapshotPath">Full path to the snapshot JSON file.</param>
+		public static IReadOnlyList<ComponentHealthReport>? LoadSnapshot(string snapshotPath)
+		{
+			if (!File.Exists(snapshotPath))
+				return null;
+
+			try
+			{
+				var json = File.ReadAllText(snapshotPath);
+				var reports = JsonSerializer.Deserialize<List<ComponentHealthReport>>(json, SerializerOptions);
+				return reports;
+			}
+			catch (JsonException)
+			{
+				return null;
+			}
+			catch (IOException)
+			{
+				return null;
+			}
+		}
+	}
+}

src/BlazorWebFormsComponents/ServiceCollectionExtensions.cs

@@ -44,16 +44,51 @@ public static IServiceCollection AddBlazorWebFormsComponents(this IServiceCollec
     /// Adds the Component Health Dashboard diagnostic service as a singleton.
     /// Loads reference baselines from dev-docs/reference-baselines.json and enables
     /// runtime reflection-based health scoring of all tracked components.
+    /// Falls back to a pre-generated health-snapshot.json when the repository
+    /// filesystem is not available (e.g., in Docker containers).
     /// </summary>
     /// <param name="services">The service collection</param>
     /// <param name="solutionRoot">Path to the repository root (for file scanning of tests, docs, samples).</param>
     /// <returns>The service collection for chaining</returns>
     public static IServiceCollection AddComponentHealthDashboard(this IServiceCollection services, string solutionRoot)
     {
         var baselinesPath = System.IO.Path.Combine(solutionRoot, "dev-docs", "reference-baselines.json");
-        var baselines = ReferenceBaselines.LoadFromFile(baselinesPath);
-        var healthService = new ComponentHealthService(baselines, solutionRoot);
-        services.AddSingleton(healthService);
+        var trackedPath = System.IO.Path.Combine(solutionRoot, "dev-docs", "tracked-components.json");
+
+        // If the repo filesystem exists, use live reflection/file scanning
+        if (System.IO.File.Exists(baselinesPath) || System.IO.File.Exists(trackedPath))
+        {
+            var baselines = ReferenceBaselines.LoadFromFile(baselinesPath);
+            var healthService = new ComponentHealthService(baselines, solutionRoot);
+            services.AddSingleton(healthService);
+            return services;
+        }
+
+        // Fallback: look for a pre-generated snapshot alongside the running assembly
+        var assemblyDir = System.IO.Path.GetDirectoryName(typeof(ComponentHealthService).Assembly.Location) ?? "";
+        var snapshotPath = System.IO.Path.Combine(assemblyDir, HealthSnapshotGenerator.SnapshotFileName);
+        var snapshotReports = HealthSnapshotGenerator.LoadSnapshot(snapshotPath);
+
+        // Also check the app's base directory (common for published apps)
+        if (snapshotReports == null)
+        {
+            snapshotPath = System.IO.Path.Combine(System.AppContext.BaseDirectory, HealthSnapshotGenerator.SnapshotFileName);
+            snapshotReports = HealthSnapshotGenerator.LoadSnapshot(snapshotPath);
+        }
+
+        if (snapshotReports != null)
+        {
+            var healthService = new ComponentHealthService(snapshotReports);
+            services.AddSingleton(healthService);
+        }
+        else
+        {
+            // Last resort: use empty baselines (components will show partial health)
+            var baselines = ReferenceBaselines.LoadFromFile(baselinesPath);
+            var healthService = new ComponentHealthService(baselines, solutionRoot);
+            services.AddSingleton(healthService);
+        }
+
         return services;
     }