Program.cs

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.Agents.Orchestration.GroupChat;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.Ollama;
using RedTeamingTool.Extensions;
using RedTeamingTool.Agents;
using RedTeamingTool.Config;
using RedTeamingTool.Constants;
using RedTeamingTool.Services;
using RedTeamingTool.Services.Interfaces;
using RedTeamingTool.UI;
using Spectre.Console;

namespace RedTeamingTool
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            try
            {
                AnsiConsole.Write(
                    new FigletText("Red Teaming Tool")
                    .Color(Color.Red));
                
                AnsiConsole.MarkupLine("[yellow]Starting up...[/]");
                var host = CreateHostBuilder(args).Build();
                
                // Get the ConsoleUI service and run it
                var consoleUI = host.Services.GetRequiredService<ConsoleUI>();
                await consoleUI.RunAsync();
            }
            catch (Exception ex)
            {
                AnsiConsole.WriteException(ex, ExceptionFormats.ShortenPaths | ExceptionFormats.ShortenTypes |
                                              ExceptionFormats.ShortenMethods | ExceptionFormats.ShowLinks);
                AnsiConsole.WriteLine("\nPress any key to exit...");
                Console.ReadKey();
            }
        }

        private static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureAppConfiguration((hostingContext, config) =>
                {
                    config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
                    config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true);
                    config.AddEnvironmentVariables();
                })
                .ConfigureServices((hostContext, services) =>
                {
                    // Register configuration options
                    services.Configure<AzureOpenAIConfig>(hostContext.Configuration.GetSection("AzureOpenAI"));
                    services.Configure<OllamaConfig>(hostContext.Configuration.GetSection("Ollama"));
                    services.Configure<RedTeamingConfig>(hostContext.Configuration.GetSection("RedTeaming"));
                    
                    // Register HTTP client
                    services.AddHttpClient();
                    
                    // Register Semantic Kernel
                    var azureConfig = hostContext.Configuration.GetSection("AzureOpenAI").Get<AzureOpenAIConfig>();
                    var ollamaConfig = hostContext.Configuration.GetSection("Ollama").Get<OllamaConfig>();
                    
                    // Create kernel with named services
                    services.AddSingleton<Kernel>(sp =>
                    {
                        var builder = Kernel.CreateBuilder();
                        
                        // Add Azure OpenAI with a service ID
                        if (azureConfig != null)
                        {
                            builder.AddAzureOpenAIChatCompletion(
                                deploymentName: azureConfig.DeploymentName ?? "gpt-4",
                                endpoint: azureConfig.Endpoint ?? "https://api.openai.com/",
                                apiKey: azureConfig.ApiKey ?? "default-key",
                                serviceId: ServiceIds.AzureOpenAI);
                        }
                            
                        // Add Ollama with a service ID
                        if (ollamaConfig != null)
                        {
                            builder.Services.AddTransient(s =>
                            {
                                var client = new HttpClient(new HttpClientHandler());
                                client.BaseAddress = new Uri("http://localhost:11434/");
                                client.Timeout = TimeSpan.FromMinutes(20);
                                return client;
                            });

                            builder.Services.AddOllamaChatCompletion(modelId: "gpt-oss:20b", serviceId: ServiceIds.Ollama);
                            //builder.AddOllamaChatCompletion(
                            //    modelId: ollamaConfig.Model ?? "gpt-oss:20b",
                            //    endpoint: new Uri(ollamaConfig.Endpoint ?? "http://localhost:11434/"),
                            //    serviceId: ServiceIds.Ollama);
                            //builder.AddOpenAIChatCompletion("gpt-oss:20b", 
                            //    new Uri("http://localhost:11434/"), 
                            //    ServiceIds.Ollama);
                        }
                            
                        return builder.Build();
                    });
                    
                    // Register the red teaming service directly
                    services.AddSingleton<IRedTeamingService, RedTeamingService>();
                    
                    // Register prompt service
                    services.AddSingleton<PromptService>();
                    
                    // Register the group chat
                    services.AddSingleton<RedTeamingGroupChat>();
                    
                    // Register Ollama test service
                    services.AddSingleton<OllamaTestService>();
                    
                    // Register attack summary service
                    services.AddSingleton<AttackSummaryService>();
                    
                    // Register email tool misuse test service
                    services.AddSingleton<EmailToolMisuseTest>();
                    
                    // Register findings export service
                    services.AddSingleton<FindingsExportService>();
                    
                    // Register UI
                    services.AddSingleton<ConsoleUI>();
                })
                .ConfigureLogging((hostContext, logging) =>
                {
                    logging.ClearProviders();
                    logging.AddConsole();
                    
                    // Set minimum log level from configuration
                    logging.AddFilter("Microsoft", LogLevel.Warning);
                    logging.AddFilter("System", LogLevel.Warning);
                    
                    if (hostContext.HostingEnvironment.IsDevelopment())
                    {
                        logging.AddDebug();
                    }
                });
    }
}