PLAN: Move to new Processor Model

[MrHinsh]

This is a new example that puts ProcessorContainer, IProcessor implementations, ProcessorLoaderService, Engine, and the Program.cs setup. This example demonstrates how to dynamically load and execute processors using configuration and dependency injection in .NET.

Processors.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;

public class ProcessorContainer : List<IProcessor>
{
}

public interface IProcessor
{
    Task<int> ExecuteAsync();
}

public interface IProcessor<TOptions> : IProcessor
{
    TOptions Options { get; init; }
}

public class ProcessorA : IProcessor<ProcessorA.Settings>
{
    public class Settings
    {
        public string Title { get; set; }
    }

    public ProcessorA(IOptions<Settings> options)
    {
        Options = options.Value;
    }

    public Settings Options { get; init; }

    public Task<int> ExecuteAsync()
    {
        Console.WriteLine($"Processor A: {Options.Title}");
        return Task.FromResult(0);
    }
}

public class ProcessorB : IProcessor<ProcessorB.Settings>
{
    public class Settings
    {
        public string OtherTitle { get; set; }
    }

    public ProcessorB(IOptions<Settings> options)
    {
        Options = options.Value;
    }

    public Settings Options { get; init; }

    public Task<int> ExecuteAsync()
    {
        Console.WriteLine($"Processor B: {Options.OtherTitle}");
        return Task.FromResult(0);
    }
}

public class ProcessorLoaderService
{
    private readonly IConfiguration _configuration;
    private readonly IServiceProvider _serviceProvider;

    public ProcessorLoaderService(IConfiguration configuration, IServiceProvider serviceProvider)
    {
        _configuration = configuration;
        _serviceProvider = serviceProvider;
    }

    public ProcessorContainer LoadProcessors()
    {
        var container = new ProcessorContainer();

        var processorsSection = _configuration.GetSection("Processors");
        var processorDefaultsSection = _configuration.GetSection("ProcessorDefaults");

        foreach (var processorConfig in processorsSection.GetChildren())
        {
            var processorType = processorConfig.GetValue<string>("ProcessorType");

            switch (processorType)
            {
                case "ProcessorA":
                    var processorAOptions = processorDefaultsSection.GetSection("ProcessorA").Get<ProcessorA.Settings>();
                    processorConfig.Bind(processorAOptions);
                    var processorAOptionsInstance = Options.Create(processorAOptions);
                    var processorA = ActivatorUtilities.CreateInstance<ProcessorA>(_serviceProvider, processorAOptionsInstance);
                    container.Add(processorA);
                    break;

                case "ProcessorB":
                    var processorBOptions = processorDefaultsSection.GetSection("ProcessorB").Get<ProcessorB.Settings>();
                    processorConfig.Bind(processorBOptions);
                    var processorBOptionsInstance = Options.Create(processorBOptions);
                    var processorB = ActivatorUtilities.CreateInstance<ProcessorB>(_serviceProvider, processorBOptionsInstance);
                    container.Add(processorB);
                    break;

                default:
                    throw new InvalidOperationException($"Unknown processor type: {processorType}");
            }
        }

        return container;
    }
}

public class Engine
{
    private readonly ProcessorContainer _processorContainer;

    public Engine(ProcessorContainer processorContainer)
    {
        _processorContainer = processorContainer;
    }

    public async Task RunAsync()
    {
        foreach (var processor in _processorContainer)
        {
            await processor.ExecuteAsync();
        }
    }
}

appsettings.json

{
  "Processors": [
    {
      "ProcessorType": "ProcessorB"
    },
    {
      "ProcessorType": "ProcessorA"
    },
    {
      "ProcessorType": "ProcessorB"
    }
  ],
  "ProcessorDefaults": {
    "ProcessorB": {
      "OtherTitle": "Test 2"
    },
    "ProcessorA": {
      "Title": "Test 1"
    }
  }
}

Program.cs

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static async Task Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();

        var serviceProvider = host.Services;

        // Load and register processors
        var processorLoader = serviceProvider.GetRequiredService<ProcessorLoaderService>();
        var processorContainer = processorLoader.LoadProcessors();

        // Ensure ProcessorContainer is available in DI
        serviceProvider.GetRequiredService<ProcessorContainer>().AddRange(processorContainer);

        // Run the engine
        var engine = serviceProvider.GetRequiredService<Engine>();
        await engine.RunAsync();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((context, services) =>
            {
                var configuration = new ConfigurationBuilder()
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                    .AddEnvironmentVariables() // Add environment variables
                    .Build();

                services.AddSingleton<IConfiguration>(configuration);
                services.AddSingleton<ProcessorLoaderService>();
                services.AddSingleton<ProcessorContainer>(); // Singleton to persist across the app lifecycle
                services.AddTransient<Engine>(); // Add Engine as a transient service
                services.AddOptions();
            });
}

Explanation and Flow

1. Processor Classes (ProcessorA and ProcessorB): These classes implement the IProcessor interface and accept their settings via IOptions<T>. They each have an ExecuteAsync method that prints out a message.

2. ProcessorContainer: A container that holds a list of IProcessor instances.

3. ProcessorLoaderService: This service loads processor configurations from appsettings.json, merges them with defaults (and environment variables), and creates instances of the processors using DI.

4. Engine: The Engine class iterates over the processors in ProcessorContainer and runs their ExecuteAsync methods.

5. Program.cs:

   • Configures the application and registers necessary services.
   • Loads the processors and registers them into the ProcessorContainer.
   • Runs the Engine, which processes each processor.

Running the Application

When you run the application, the following occurs:

• The processors are dynamically loaded based on the configuration.
• The Engine executes each processor in the order specified in the configuration.
• The output will display messages indicating that ProcessorA and ProcessorB have been executed with their respective settings.

This structure provides a flexible and maintainable approach to dynamically configuring and executing processors in a .NET application.

[MrHinsh]

WITH ENRICHERS

To handle the scenario where each processor has associated "Enrichers" that need to be mapped to IEnricher and IEnricherSettings, you can extend your implementation as follows:

1. Define the IEnricher and IEnricherSettings Interfaces

These interfaces define the contract for the enrichers.

public interface IEnricher
{
    void Enrich();
}

public interface IEnricherSettings
{
    string Title { get; set; }
}

public class Enricher1 : IEnricher
{
    public class Settings : IEnricherSettings
    {
        public string Title { get; set; }
    }

    private readonly Settings _settings;

    public Enricher1(Settings settings)
    {
        _settings = settings;
    }

    public void Enrich()
    {
        Console.WriteLine($"Enricher1 with title: {_settings.Title}");
    }
}

public class Enricher2 : IEnricher
{
    public class Settings : IEnricherSettings
    {
        public string Title { get; set; }
    }

    private readonly Settings _settings;

    public Enricher2(Settings settings)
    {
        _settings = settings;
    }

    public void Enrich()
    {
        Console.WriteLine($"Enricher2 with title: {_settings.Title}");
    }
}

2. Update the Processor Classes to Handle Enrichers

Now, update your processor classes (ProcessorA and ProcessorB) to include enrichers.

public interface IProcessor<TOptions> : IProcessor
{
    TOptions Options { get; init; }
    List<IEnricher> Enrichers { get; init; }
}

public class ProcessorA : IProcessor<ProcessorA.Settings>
{
    public class Settings
    {
        public string Title { get; set; }
    }

    public ProcessorA(IOptions<Settings> options, List<IEnricher> enrichers)
    {
        Options = options.Value;
        Enrichers = enrichers;
    }

    public Settings Options { get; init; }
    public List<IEnricher> Enrichers { get; init; }

    public Task<int> ExecuteAsync()
    {
        Console.WriteLine($"Processor A: {Options.Title}");
        foreach (var enricher in Enrichers)
        {
            enricher.Enrich();
        }
        return Task.FromResult(0);
    }
}

public class ProcessorB : IProcessor<ProcessorB.Settings>
{
    public class Settings
    {
        public string OtherTitle { get; set; }
    }

    public ProcessorB(IOptions<Settings> options, List<IEnricher> enrichers)
    {
        Options = options.Value;
        Enrichers = enrichers;
    }

    public Settings Options { get; init; }
    public List<IEnricher> Enrichers { get; init; }

    public Task<int> ExecuteAsync()
    {
        Console.WriteLine($"Processor B: {Options.OtherTitle}");
        foreach (var enricher in Enrichers)
        {
            enricher.Enrich();
        }
        return Task.FromResult(0);
    }
}

3. Modify ProcessorLoaderService to Handle Enrichers

The ProcessorLoaderService needs to be modified to handle the creation and configuration of enrichers.

public class ProcessorLoaderService
{
    private readonly IConfiguration _configuration;
    private readonly IServiceProvider _serviceProvider;

    public ProcessorLoaderService(IConfiguration configuration, IServiceProvider serviceProvider)
    {
        _configuration = configuration;
        _serviceProvider = serviceProvider;
    }

    public ProcessorContainer LoadProcessors()
    {
        var container = new ProcessorContainer();

        var processorsSection = _configuration.GetSection("Processors");
        var processorDefaultsSection = _configuration.GetSection("ProcessorDefaults");

        foreach (var processorConfig in processorsSection.GetChildren())
        {
            var processorType = processorConfig.GetValue<string>("ProcessorType");
            List<IEnricher> enrichers = LoadEnrichers(processorConfig, processorDefaultsSection.GetSection(processorType));

            switch (processorType)
            {
                case "ProcessorA":
                    var processorAOptions = processorDefaultsSection.GetSection("ProcessorA").Get<ProcessorA.Settings>();
                    processorConfig.Bind(processorAOptions);
                    var processorAOptionsInstance = Options.Create(processorAOptions);
                    var processorA = ActivatorUtilities.CreateInstance<ProcessorA>(_serviceProvider, processorAOptionsInstance, enrichers);
                    container.Add(processorA);
                    break;

                case "ProcessorB":
                    var processorBOptions = processorDefaultsSection.GetSection("ProcessorB").Get<ProcessorB.Settings>();
                    processorConfig.Bind(processorBOptions);
                    var processorBOptionsInstance = Options.Create(processorBOptions);
                    var processorB = ActivatorUtilities.CreateInstance<ProcessorB>(_serviceProvider, processorBOptionsInstance, enrichers);
                    container.Add(processorB);
                    break;

                default:
                    throw new InvalidOperationException($"Unknown processor type: {processorType}");
            }
        }

        return container;
    }

    private List<IEnricher> LoadEnrichers(IConfiguration processorConfig, IConfiguration defaultsSection)
    {
        var enrichers = new List<IEnricher>();
        var enrichersSection = processorConfig.GetSection("Enrichers");
        var defaultsEnrichersSection = defaultsSection.GetSection("Enrichers");

        foreach (var enricherConfig in enrichersSection.GetChildren())
        {
            var enricherType = enricherConfig.Key;

            switch (enricherType)
            {
                case "Enricher1":
                    var enricher1Settings = defaultsEnrichersSection.GetSection("Enricher1").Get<Enricher1.Settings>();
                    enricherConfig.Bind(enricher1Settings);
                    var enricher1 = new Enricher1(enricher1Settings);
                    enrichers.Add(enricher1);
                    break;

                case "Enricher2":
                    var enricher2Settings = defaultsEnrichersSection.GetSection("Enricher2").Get<Enricher2.Settings>();
                    enricherConfig.Bind(enricher2Settings);
                    var enricher2 = new Enricher2(enricher2Settings);
                    enrichers.Add(enricher2);
                    break;

                // Handle other enrichers similarly
                default:
                    throw new InvalidOperationException($"Unknown enricher type: {enricherType}");
            }
        }

        return enrichers;
    }
}

4. Update Program.cs for DI Setup

Ensure that Program.cs is properly set up to inject dependencies and run the application.

public class Program
{
    public static async Task Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();

        var serviceProvider = host.Services;

        // Load and register processors
        var processorLoader = serviceProvider.GetRequiredService<ProcessorLoaderService>();
        var processorContainer = processorLoader.LoadProcessors();

        // Ensure ProcessorContainer is available in DI
        serviceProvider.GetRequiredService<ProcessorContainer>().AddRange(processorContainer);

        // Run the engine
        var engine = serviceProvider.GetRequiredService<Engine>();
        await engine.RunAsync();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((context, services) =>
            {
                var configuration = new ConfigurationBuilder()
                    .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                    .AddEnvironmentVariables() // Add environment variables
                    .Build();

                services.AddSingleton<IConfiguration>(configuration);
                services.AddSingleton<ProcessorLoaderService>();
                services.AddSingleton<ProcessorContainer>(); // Singleton to persist across the app lifecycle
                services.AddTransient<Engine>(); // Add Engine as a transient service
                services.AddOptions();
            });
}

Explanation of the Complete Process

1. Enrichers and Settings: IEnricher and IEnricherSettings interfaces allow for flexible enrichment functionality that can be associated with processors.

2. Processor Classes: Processors (ProcessorA, ProcessorB) have a List<IEnricher> property that stores the enrichers. The ExecuteAsync method iterates through and invokes each enricher's Enrich method.

3. Loading Enrichers: The ProcessorLoaderService loads enrichers for each processor by merging the processor-specific configuration with default configurations. Enrichers are instantiated dynamically based on their types.

4. Program.cs: Sets up dependency injection, loads the configuration, and initializes the engine to run all processors.

Running the Application

When running the application:

• The processors are dynamically created based on the configuration.
• Each processor is associated with its respective enrichers, configured based on both defaults and specific overrides.
• The engine iterates over the processors, and each processor executes its ExecuteAsync method, invoking its enrichers.

This setup provides a flexible and scalable way to manage processors and their associated enrichers in a .NET application.

[MrHinsh]

Possibly add Writable Optons

To make the Processor options writable using the provided IWritableOptions interface and WritableOptions class, you can integrate the writable options pattern into your existing application. Below is a step-by-step guide on how to use these classes to allow modification of Processor options at runtime and persist those changes to the appsettings.json file.

1. Update WritableOptions and Service Registration

The provided WritableOptions and extension methods assume that you're using IHostingEnvironment, which is part of the old ASP.NET Core environment API. In modern .NET Core/5/6/7+ projects, this has been replaced with IWebHostEnvironment or IHostEnvironment. Let's update the code to use IHostEnvironment for broader compatibility:

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.IO;

public interface IWritableOptions<out T> : IOptionsSnapshot<T> where T : class, new()
{
    void Update(Action<T> applyChanges);
}

public class WritableOptions<T> : IWritableOptions<T> where T : class, new()
{
    private readonly IHostEnvironment _environment;
    private readonly IOptionsMonitor<T> _options;
    private readonly string _section;
    private readonly string _file;

    public WritableOptions(
        IHostEnvironment environment,
        IOptionsMonitor<T> options,
        string section,
        string file)
    {
        _environment = environment;
        _options = options;
        _section = section;
        _file = file;
    }

    public T Value => _options.CurrentValue;
    public T Get(string name) => _options.Get(name);

    public void Update(Action<T> applyChanges)
    {
        var fileProvider = _environment.ContentRootFileProvider;
        var fileInfo = fileProvider.GetFileInfo(_file);
        var physicalPath = fileInfo.PhysicalPath;

        var jObject = JsonConvert.DeserializeObject<JObject>(File.ReadAllText(physicalPath));
        var sectionObject = jObject.TryGetValue(_section, out JToken section) ?
            JsonConvert.DeserializeObject<T>(section.ToString()) : (Value ?? new T());

        applyChanges(sectionObject);

        jObject[_section] = JObject.Parse(JsonConvert.SerializeObject(sectionObject));
        File.WriteAllText(physicalPath, JsonConvert.SerializeObject(jObject, Formatting.Indented));
    }
}

public static class ServiceCollectionExtensions
{
    public static void ConfigureWritable<T>(
        this IServiceCollection services,
        IConfigurationSection section,
        string file = "appsettings.json") where T : class, new()
    {
        services.Configure<T>(section);
        services.AddTransient<IWritableOptions<T>>(provider =>
        {
            var environment = provider.GetService<IHostEnvironment>();
            var options = provider.GetService<IOptionsMonitor<T>>();
            return new WritableOptions<T>(environment, options, section.Key, file);
        });
    }
}

2. Register the Writable Options in Program.cs

Next, update the Program.cs to register the writable options for your processors.

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

public class Program
{
    public static void Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();

        var serviceProvider = host.Services;

        // Example of how to update ProcessorA's settings at runtime
        var writableProcessorAOptions = serviceProvider.GetRequiredService<IWritableOptions<ProcessorA.Settings>>();
        writableProcessorAOptions.Update(opt => opt.Title = "New Title");

        // Your existing code to run the processors, etc.
        var processorLoader = serviceProvider.GetRequiredService<ProcessorLoaderService>();
        var processorContainer = processorLoader.LoadProcessors();

        serviceProvider.GetRequiredService<ProcessorContainer>().AddRange(processorContainer);

        var engine = serviceProvider.GetRequiredService<Engine>();
        engine.RunAsync().Wait();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureServices((context, services) =>
            {
                var configuration = new ConfigurationBuilder()
                    .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                    .AddEnvironmentVariables()
                    .Build();

                services.AddSingleton<IConfiguration>(configuration);
                services.AddSingleton<ProcessorLoaderService>();
                services.AddSingleton<ProcessorContainer>();
                services.AddTransient<Engine>();

                // Register writable options
                services.ConfigureWritable<ProcessorA.Settings>(configuration.GetSection("MigrationTools:CommonEnrichers:ProcessorA"));
                services.ConfigureWritable<ProcessorB.Settings>(configuration.GetSection("MigrationTools:CommonEnrichers:ProcessorB"));

                // Add other dependencies as needed
            });
}

3. Usage in Application Code

To update the configuration of a processor at runtime, you can retrieve the IWritableOptions<T> service and call the Update method. This method allows you to modify the processor's settings and persist the changes to appsettings.json.

Example usage:

public class SomeService
{
    private readonly IWritableOptions<ProcessorA.Settings> _writableProcessorAOptions;

    public SomeService(IWritableOptions<ProcessorA.Settings> writableProcessorAOptions)
    {
        _writableProcessorAOptions = writableProcessorAOptions;
    }

    public void ChangeProcessorASetting()
    {
        _writableProcessorAOptions.Update(options =>
        {
            options.Title = "Updated Title from SomeService";
        });
    }
}

4. Explanation of the Changes

• IWritableOptions<T>: This interface extends IOptionsSnapshot<T> and adds an Update method to modify and persist configuration settings at runtime.
• WritableOptions<T>: This class implements IWritableOptions<T> and handles reading, updating, and saving the configuration settings back to the appsettings.json file.
• Service Registration: The ConfigureWritable extension method registers the writable options in the DI container, making them available for injection and runtime updates.
• Usage: You can inject IWritableOptions<T> into any service and call the Update method to modify the settings and persist those changes.

Conclusion

With this setup, your application can programmatically modify and persist configuration settings for processors (or any other configuration) directly to the appsettings.json file at runtime. This is particularly useful for scenarios where configuration might change based on user input or other runtime conditions.

[MrHinsh]

Add config editor

To create an interactive command-line experience where users can select processors from a list and then add their selection to the configuration, you can utilize Spectre.Console's interactive prompts. Below is an updated implementation that prompts the user to select processors and then adds them to the appsettings.json configuration.

Updated Implementation

This implementation will present the user with a list of processors, allow them to select one or more, and then update the configuration file accordingly.

using System;
using System.IO;
using Microsoft.Extensions.Configuration;
using Newtonsoft.Json.Linq;
using Spectre.Console;
using Spectre.Console.Cli;

public class ConfigCommand : Command<ConfigCommand.Settings>
{
    public class Settings : CommandSettings
    {
        [CommandOption("-a|--add")]
        public bool AddProcessor { get; set; }
    }

    public override int Execute(CommandContext context, Settings settings)
    {
        // Load configuration
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .Build();

        if (settings.AddProcessor)
        {
            // Prompt the user to select processors and add them to the configuration
            AddProcessorToConfig(configuration);
        }
        else
        {
            // Display configuration
            DisplayConfig(configuration);
        }

        return 0;
    }

    private void DisplayConfig(IConfiguration configuration)
    {
        var root = new Tree("Configuration");

        // Display each section in the configuration
        foreach (var section in configuration.GetChildren())
        {
            var sectionTree = new Tree(section.Key);
            AddChildren(section, sectionTree);
            root.AddNode(sectionTree);
        }

        AnsiConsole.Write(root);
    }

    private void AddChildren(IConfigurationSection section, Tree tree)
    {
        foreach (var child in section.GetChildren())
        {
            var childTree = new Tree($"{child.Key}: {child.Value}");
            tree.AddNode(childTree);

            if (child.GetChildren() != null)
            {
                AddChildren(child, childTree);
            }
        }
    }

    private void AddProcessorToConfig(IConfiguration configuration)
    {
        // Define available processors
        var availableProcessors = new[]
        {
            "WorkItemMigrationProcessor",
            "GitRepoMigrationProcessor",
            "AreaPathMigrationProcessor"
        };

        // Prompt the user to select processors
        var selectedProcessor = AnsiConsole.Prompt(
            new SelectionPrompt<string>()
                .Title("Select a processor to add to the configuration:")
                .PageSize(10)
                .AddChoices(availableProcessors));

        // Get additional settings from the user if necessary
        var enabled = AnsiConsole.Confirm("Should this processor be enabled?", true);

        // Update the configuration file
        UpdateConfig(configuration, selectedProcessor, enabled);
    }

    private void UpdateConfig(IConfiguration configuration, string processorType, bool enabled)
    {
        // Load JSON file into JObject
        var filePath = "appsettings.json";
        var json = File.ReadAllText(filePath);
        var jsonObj = JObject.Parse(json);

        // Create a new processor configuration
        var newProcessor = new JObject
        {
            { "ProcessorType", processorType },
            { "Enabled", enabled }
            // You can add more settings here if needed
        };

        // Add the new processor to the Processors array
        var processorsArray = (JArray)jsonObj["MigrationTools"]["Processors"];
        processorsArray.Add(newProcessor);

        // Write the updated configuration back to the file
        File.WriteAllText(filePath, jsonObj.ToString());

        AnsiConsole.MarkupLine("[green]Processor added to configuration successfully![/]");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var app = new CommandApp();
        app.Configure(config =>
        {
            config.AddCommand<ConfigCommand>("config")
                .WithDescription("View or modify the configuration")
                .WithExample(new[] { "config" })
                .WithExample(new[] { "config", "--add" });
        });

        app.Run(args);
    }
}

Explanation of the Code

1. Settings Class: A CommandSettings class is used to define a command option --add (-a) that triggers the processor addition mode.

2. AddProcessorToConfig Method:

   • Uses AnsiConsole.Prompt to present the user with a list of available processors to select from.
   • Prompts the user to enable the processor.
   • Calls UpdateConfig to add the selected processor to the configuration.

3. UpdateConfig Method:

   • Reads the existing appsettings.json file.
   • Adds the new processor configuration to the Processors array in the MigrationTools section.
   • Saves the updated configuration back to appsettings.json.

4. Command Registration: In Program.cs, the command is registered with Spectre.Console.Cli, enabling you to run the configuration command with or without the --add option.

Running the Application

• To display the current configuration:

  dotnet run -- config

• To add a new processor to the configuration:

  dotnet run -- config --add

When running the --add option, the application will interactively prompt you to select a processor and enable it, then update appsettings.json accordingly.

Conclusion

This implementation demonstrates how to use Spectre.Console for interactive command-line operations, allowing users to modify configuration files dynamically. The application provides a user-friendly interface to select processors and update configurations, making it a powerful tool for managing complex setups.