Introduce Vexer platform scaffolding and enrich Concelier merge

src/StellaOps.Cli/Services/AuthorityDiagnosticsReporter.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using StellaOps.Authority.Plugins.Abstractions;
+using StellaOps.Configuration;
+
+namespace StellaOps.Cli.Services;
+
+/// <summary>
+/// Emits Authority configuration diagnostics discovered during CLI startup.
+/// </summary>
+internal static class AuthorityDiagnosticsReporter
+{
+    public static void Emit(IConfiguration configuration, ILogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+        ArgumentNullException.ThrowIfNull(logger);
+
+        var basePath = Directory.GetCurrentDirectory();
+        EmitInternal(configuration, logger, basePath);
+    }
+
+    internal static void Emit(IConfiguration configuration, ILogger logger, string basePath)
+    {
+        ArgumentNullException.ThrowIfNull(configuration);
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(basePath);
+
+        EmitInternal(configuration, logger, basePath);
+    }
+
+    private static void EmitInternal(IConfiguration configuration, ILogger logger, string basePath)
+    {
+        if (string.IsNullOrWhiteSpace(basePath))
+        {
+            basePath = Directory.GetCurrentDirectory();
+        }
+
+        var authoritySection = configuration.GetSection("Authority");
+        if (!authoritySection.Exists())
+        {
+            return;
+        }
+
+        var authorityOptions = new StellaOpsAuthorityOptions();
+        authoritySection.Bind(authorityOptions);
+
+        if (authorityOptions.Plugins.Descriptors.Count == 0)
+        {
+            return;
+        }
+
+        var resolvedBasePath = Path.GetFullPath(basePath);
+        IReadOnlyList<AuthorityPluginContext> contexts;
+
+        try
+        {
+            contexts = AuthorityPluginConfigurationLoader.Load(authorityOptions, resolvedBasePath);
+        }
+        catch (Exception ex)
+        {
+            logger.LogDebug(ex, "Failed to load Authority plug-in configuration for diagnostics.");
+            return;
+        }
+
+        if (contexts.Count == 0)
+        {
+            return;
+        }
+
+        IReadOnlyList<AuthorityConfigurationDiagnostic> diagnostics;
+        try
+        {
+            diagnostics = AuthorityPluginConfigurationAnalyzer.Analyze(contexts);
+        }
+        catch (Exception ex)
+        {
+            logger.LogDebug(ex, "Failed to analyze Authority plug-in configuration for diagnostics.");
+            return;
+        }
+
+        if (diagnostics.Count == 0)
+        {
+            return;
+        }
+
+        var contextLookup = new Dictionary<string, AuthorityPluginContext>(StringComparer.OrdinalIgnoreCase);
+        foreach (var context in contexts)
+        {
+            if (context?.Manifest?.Name is { Length: > 0 } name && !contextLookup.ContainsKey(name))
+            {
+                contextLookup[name] = context;
+            }
+        }
+
+        foreach (var diagnostic in diagnostics)
+        {
+            var level = diagnostic.Severity switch
+            {
+                AuthorityConfigurationDiagnosticSeverity.Error => LogLevel.Error,
+                AuthorityConfigurationDiagnosticSeverity.Warning => LogLevel.Warning,
+                _ => LogLevel.Information
+            };
+
+            if (!logger.IsEnabled(level))
+            {
+                continue;
+            }
+
+            if (contextLookup.TryGetValue(diagnostic.PluginName, out var context) &&
+                context?.Manifest?.ConfigPath is { Length: > 0 } configPath)
+            {
+                logger.Log(level, "{DiagnosticMessage} (config: {ConfigPath})", diagnostic.Message, configPath);
+            }
+            else
+            {
+                logger.Log(level, "{DiagnosticMessage}", diagnostic.Message);
+            }
+        }
+    }
+}