Program.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
//using System.Threading.Tasks;
using Azure;
using Azure.AI.OpenAI;
//using OpenAI_API.Chat;
//using System.Linq;

class Program
{
    static string rootPath = AppDomain.CurrentDomain.BaseDirectory;
    static int maxTokensPerChunk = 50000; // Default value
    static string logFilePath = Path.Combine(rootPath, "logs", $"default-{Guid.NewGuid()}.log");
    static string modelName = "gpt-4"; // Default value
    static string patternsFolder = Path.Combine(rootPath, "patterns"); // Default value
    static string apiKey  = string.Empty;
    static string userPrompt  = string.Empty;
    static string[] patterns;

    static async Task Main(string[] args)
    {

        LoadConfigurationsFromEnvFile();
        ParseArguments(args);

        Logger.Initialize(logFilePath);
        Logger.LogInfo("Application started");

        if (Console.IsInputRedirected)
        {
            using (var reader = new StreamReader(Console.OpenStandardInput(), Console.InputEncoding))
            {
                userPrompt = reader.ReadToEnd();
            }
        }

        if ((patterns?.Length ?? 0) == 0 || string.IsNullOrEmpty(userPrompt))
        {
            Console.WriteLine($"rootPath = {rootPath}");
            Console.WriteLine($"logFilePath = {logFilePath}");
            Console.WriteLine($"patternsFolder = {patternsFolder}");
            Console.WriteLine($"ModelName = {modelName}");
            Logger.LogError("Patterns and user prompt are required.");
            return;
        }

        if (string.IsNullOrEmpty(apiKey))
        {
            Logger.LogError("Please set your OpenAI API key in the .env file or as a command-line argument.");
            return;
        }

        var client = new OpenAIClient(apiKey, new OpenAIClientOptions());

        foreach (var pattern in patterns)
        {
            Logger.LogInfo($"Load Pattern: {pattern}");

            var patternData = LoadPattern(pattern);
            if (patternData == null)
            {
                Logger.LogError($"Pattern files not found for: {pattern}");
                return;
            }

            LogPatternInfo(pattern, patternData.Item1, userPrompt);

            var responses = await SendRequestInChunks(client, patternData.Item1, userPrompt);
            if (responses == null || responses.Count == 0)
            {
                Logger.LogError("Failed to get a valid response from the API.");
                return;
            }

            userPrompt = string.Join(" ", responses);
            Logger.LogInfo("*********************************************************");
            Logger.LogInfo($"Pattern Response For: {pattern}");
            Logger.LogInfo("*********************************************************");
            Logger.LogInfo(userPrompt);
            Logger.LogInfo("*********************************************************");
            Logger.LogInfo($"Pattern Response END For: {pattern}");
            Logger.LogInfo("*********************************************************");
        }

        if (!string.IsNullOrEmpty(userPrompt))
        {
            Logger.LogInfo("Output generated successfully");
            File.WriteAllText(Path.Combine(rootPath, "output.txt"), userPrompt);
            Console.WriteLine(userPrompt);
        }

        Logger.LogInfo("Application ended");
    }

    static void LoadConfigurationsFromEnvFile()
    {
        var envFile = Path.Combine(rootPath, ".env");
        if (File.Exists(envFile))
        {
            foreach (var line in File.ReadAllLines(envFile))
            {
                var parts = line.Split('=', 2);
                if (parts.Length != 2) continue;
                var key = parts[0].Trim();
                var value = parts[1].Trim();

                switch (key)
                {
                    case "MAX_TOKENS_PER_CHUNK":
                        if (int.TryParse(value, out var maxTokens))
                        {
                            maxTokensPerChunk = maxTokens;
                        }
                        break;
                    case "LOG_FILE_PATH":
                        logFilePath = value;
                        break;
                    case "MODEL_NAME":
                        modelName = value;
                        break;
                    case "PATTERNS_FOLDER":
                        patternsFolder = value;
                        break;
                    case "OPENAI_API_KEY":
                        apiKey = value;
                        break;
                }
            }
        }
    }

    static void ParseArguments(string[] args)
    {
        for (int i = 0; i < args.Length; i++)
        {
            switch (args[i])
            {
                case "-maxTokens":
                    if (i + 1 < args.Length && int.TryParse(args[i + 1], out var maxTokens))
                    {
                        maxTokensPerChunk = maxTokens;
                        i++;
                    }
                    break;
                case "-logFilePath":
                    if (i + 1 < args.Length)
                    {
                        logFilePath = args[i + 1];
                        i++;
                    }
                    break;
                case "-modelName":
                    if (i + 1 < args.Length)
                    {
                        modelName = args[i + 1];
                        i++;
                    }
                    break;
                case "-patternsFolder":
                    if (i + 1 < args.Length)
                    {
                        patternsFolder = args[i + 1];
                        i++;
                    }
                    break;
                case "-apiKey":
                    if (i + 1 < args.Length)
                    {
                        apiKey = args[i + 1];
                        i++;
                    }
                    break;
                case "-userPrompt":
                    if (i + 1 < args.Length)
                    {
                        userPrompt = args[i + 1];
                        i++;
                    }
                    break;
                case "-patterns":
                    if (i + 1 < args.Length)
                    {
                        patterns = args[i + 1].Split(',');
                        i++;
                    }
                    break;
            }
        }
    }

    static Tuple<string, string> LoadPattern(string patternName)
    {
        var patternsDirectory = Path.Combine(patternsFolder, patternName);
        var systemFile = Path.Combine(patternsDirectory, "system.md");
        var prePromptFile = Path.Combine(patternsDirectory, "user.md");

        var systemPrompt = File.Exists(systemFile) ? File.ReadAllText(systemFile) : string.Empty;
        var prePrompt = File.Exists(prePromptFile) ? File.ReadAllText(prePromptFile) : string.Empty;

        return !string.IsNullOrEmpty(systemPrompt) ? new Tuple<string, string>(systemPrompt, prePrompt) : null;
    }

    static async Task<List<string>> SendRequestInChunks(OpenAIClient client, string systemPrompt, string userPrompt)
    {
        var chunks = SplitIntoChunks(userPrompt, maxTokensPerChunk);
        var responses = new List<string>();

        foreach (var chunk in chunks)
        {
            var response = await SendRequest(client, systemPrompt, chunk);
            if (response != null)
            {
                responses.Add(response);
            }
            else
            {
                Logger.LogError("Error: Failed to process chunk.");
            }
        }
        return responses;
    }

    static async Task<string> SendRequest(OpenAIClient client, string systemPrompt, string userPrompt)
    {
        var chatCompletionsOptions = new ChatCompletionsOptions
        {
            DeploymentName = modelName,
            Messages = 
            {
                new ChatRequestSystemMessage(systemPrompt),
                new ChatRequestUserMessage(userPrompt)
            }
        };

        try
        {
            var response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
            var result = new StringBuilder();
            foreach (var choice in response.Value.Choices)
            {
                result.Append(choice.Message.Content);
            }
            return result.ToString();
        }
        catch (RequestFailedException ex)
        {
            Logger.LogError("Request failed: " + ex.Message);
            return null;
        }
    }

    static List<string> SplitIntoChunks(string text, int maxTokens)
    {
        var tokens = text.Split(new[] { ' ', '\n' }, StringSplitOptions.RemoveEmptyEntries);
        var chunks = new List<string>();
        var currentChunk = new StringBuilder();
        var currentTokens = 0;

        foreach (var token in tokens)
        {
            var tokenLength = GetTokenCount(token);
            if (currentTokens + tokenLength > maxTokens)
            {
                chunks.Add(currentChunk.ToString().Trim());
                currentChunk.Clear();
                currentTokens = 0;
            }
            currentChunk.Append(token).Append(' ');
            currentTokens += tokenLength;
        }

        if (currentChunk.Length > 0)
        {
            chunks.Add(currentChunk.ToString().Trim());
        }

        return chunks;
    }

    static int GetTokenCount(string text)
    {
        return text.Length / 4; // Simplified token count approximation
    }

    static void LogPatternInfo(string pattern, string systemPrompt, string userPrompt)
    {
        Logger.LogInfo("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        Logger.LogInfo($"Pattern Request For: {pattern}");
        Logger.LogInfo("---------------------------------------------------------");
        Logger.LogInfo($"System Prompt For: {pattern}");
        Logger.LogInfo(systemPrompt);
        Logger.LogInfo("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        Logger.LogInfo(userPrompt);
        Logger.LogInfo("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
        Logger.LogInfo($"Pattern Request END For: {pattern}");
        Logger.LogInfo("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
    }
}