Program.cs

using pack;
using System.CommandLine;
using System.Net.Http.Headers;

//========define commands==========
var rootCommand = new RootCommand("root command for file bundle CLI");
var bundleCommand = new Command("bundle", "bundle code files to single file");
var createRspCommand = new Command("create-rsp", "create a response file");

//==========adding commands=========
rootCommand.AddCommand(bundleCommand);
rootCommand.AddCommand(createRspCommand);

//========define options===========
var languageOption = new Option<string>(new string[] { "--language", "-l" }, "code language list") { IsRequired = true, AllowMultipleArgumentsPerToken = true };
var outputOption = new Option<FileInfo>(new string[] { "--option", "-o" }, "file path or file name");
var noteOption = new Option<bool>(new string[] { "--note", "-n" }, "write the source as a comment in bundle");
var sortOption = new Option<string>(new string[] { "--sort", "-s" }, "the order of copying the code files");
var removeEmptyLinesOption = new Option<bool>(new string[] { "----remove", "-r" }, "remove empty lines in bundle");
var authorOption = new Option<string>(new string[] { "--author", "-a" }, "adding the author name");

//=========adding option============
bundleCommand.AddOption(languageOption);
bundleCommand.AddOption(outputOption);
bundleCommand.AddOption(noteOption);
bundleCommand.AddOption(sortOption);
bundleCommand.AddOption(removeEmptyLinesOption);
bundleCommand.AddOption(authorOption);

noteOption.SetDefaultValue(true);
sortOption.SetDefaultValue("alphabet");
removeEmptyLinesOption.SetDefaultValue(true);

//languge
Console.WriteLine("jfsvnkmxcl;");
static bool LangugeValidaton(string language)
{
    Console.WriteLine("hello LangugeValidaton");
    if (string.IsNullOrEmpty(language))
        return false;

    var languageDict = new Dictionary<string, (string Extension, bool Flag)>
        {
            { "java", (".java", false) },
            { "python", (".py", false) },
            { "c", (".c", false) },
            { "c++", (".cpp", false) },
            { "c#", (".cs", false) },
            { "javascript", (".js", false) },
            { "sql", (".sql", false) },
            { "typescript", (".ts", false) },
            { "react", (".tsx", false) },
            { "css", (".css", false) },
            { "html", (".html", false) },
            { "text", (".txt", false) }

        };

    string[] languages = language.Split(' ');

    foreach (var lang in languages)
        if (!languageDict.ContainsKey(lang))
            return false;

    return true;

}
static List<string> FilterDict(string directoryPath, List<string> files, string language)
{
    Console.WriteLine("hello FilterDict");
    if (language == "all")
        language = string.Join(" ", Language.ProgrammingLanguages.Keys);

    //get all the extension of the chosen languages
    var extension = Language.ProgrammingLanguages.Where(lang => language.Contains(lang.Key))
    .Select(lang => lang.Value);

    //filter the file include in the list, exclude bin and debug files
    var filteredFiles = files.Where(file =>
           extension.Contains(Path.GetExtension(file)) ||
           !file.Contains(Path.Combine(directoryPath, "bin")) ||
           !file.Contains(Path.Combine(directoryPath, "debug"))).ToList();

    return filteredFiles;
}

bundleCommand.SetHandler((language, output, note, sort, removeEmptyLines, author) =>
{
    Console.WriteLine("hello SetHandler");
    try
    {
        if (!LangugeValidaton(language))
            throw new InvalidOperationException("ERROR: invalid language");

        var directoryPath = Directory.GetCurrentDirectory();
        List<string> files = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories).ToList();

        if (!Directory.Exists(Path.GetDirectoryName(output.FullName)))
        {
            Directory.CreateDirectory(Path.GetDirectoryName(output.FullName));  
        }

        using (var bFile = new StreamWriter(output.FullName, append: false))
        {
            var filterFiles = FilterDict(directoryPath, files, language);

            if (sort == "alphabet")
            {
                filterFiles = filterFiles.OrderBy(f => Path.GetFileName(f)).ToList();
            }
            else
            {
                filterFiles = filterFiles.OrderBy(f => Path.GetExtension(f)).ToList();
            }

            if (!string.IsNullOrEmpty(author))
                bFile.WriteLine($"author: {author}");

            foreach (var file in filterFiles)
            {

                if (note)
                {
                    bFile.WriteLine($"file name: {Path.GetFileName(file)}: path: {Path.GetRelativePath(directoryPath, file)}");
                }

                var content = File.ReadAllLines(file);
                if (removeEmptyLines)
                {
                    content = content.Where(line => !string.IsNullOrWhiteSpace(line)).ToArray();
                }

                foreach (string line in content)
                {
                    bFile.WriteLine(line);  
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"ERROR: {ex.Message}");
    }
},
languageOption,
outputOption,
noteOption,
sortOption,
removeEmptyLinesOption,
authorOption);

//    Console.WriteLine(output.FullName);
//    try
//    {
//        using (var bFile = new StreamWriter(output.FullName, append: false))
//        {
//            if (!LangugeValidaton(language))
//                throw new InvalidOperationException("EROR: invalid language");
//            var directoryPath = Directory.GetCurrentDirectory();
//            List<string> files = Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories).ToList();
//            var filterFiles = FilterDict(directoryPath, files, language);
//            //sort
//            if (sort != "alphabet")
//            {
//                filterFiles.OrderBy(f => Path.GetExtension(f)).ToList();
//            }
//            else filterFiles = filterFiles.OrderBy(f => Path.GetFileName(f)).ToList();
//            if (!string.IsNullOrEmpty(author))
//                bFile.WriteLine($"author: {author}");
//            foreach (var file in filterFiles)
//            {
//                //note
//                if (note)
//                {
//                    bFile.WriteLine($"file name: {Path.GetFileName(file)}: path: {Path.GetRelativePath(directoryPath, file)}");
//                }
//                var content = File.ReadAllLines(file);
//                if (removeEmptyLines)
//                {
//                    content = content.Where(line => !string.IsNullOrWhiteSpace(line)).ToArray();
//                    // כתיבת השורות הלא ריקות חזרה לקובץ
//                }
//                //using (bFile = new StreamWriter(output.FullName, true)) // true מאפשר הוספה לקובץ קיים
//                //{
//                //    foreach (string line in content)
//                //    {
//                //        bFile.WriteLine(line); // כותב כל מחרוזת לקובץ
//                //    }
//                //}
//            }
//        }
//    }
//    catch (UnauthorizedAccessException)
//    {
//        Console.WriteLine("Error: Access denied to the output path.");
//    }
//    catch (Exception ex)
//    {
//        Console.WriteLine($"Error: {ex.Message}");
//    }
//},
//languageOption,
//outputOption,
//noteOption,
//sortOption,
//removeEmptyLinesOption,
//authorOption
//);

createRspCommand.SetHandler(() =>
{
    var quesAns = new Dictionary<string, string> {
    { "language (comma-separated, or 'all')", "" },
    { "include source file paths as comments in the bundle ? (true / false)", "false" },
    { "sort files by ('name' or 'type')", "name" },
    { "remove empty lines from the source files ? (true / false)", "false" },
    { "add Author to the file?(author name)", "" },
    { "output -File path and name", "" }
};
    foreach (var key in quesAns.Keys)
    {
        Console.Write($"Enter {key}: ");
        quesAns[key] = Console.ReadLine() ?? quesAns[key];
    }
    if (string.IsNullOrWhiteSpace(quesAns["language (comma-separated, or 'all'"]) ||
    string.IsNullOrWhiteSpace(quesAns["output -File path and name"]))
    {
        Console.WriteLine("Error: 'language' and 'output' are required fields.");
        return;
    }
    var rspName = "bundle.rsp";
    using (FileStream resFile = new FileStream(rspName, FileMode.CreateNew, FileAccess.Write))
    using (StreamWriter writer = new StreamWriter(resFile))
    {
        foreach (var (key, value) in quesAns)
        {
            var option = key[0];
            writer.WriteLine($"--{option} {value}");
        }
    }
    Console.WriteLine($"Response File created successfully. Run it with pack @{rspName}");
});
rootCommand.InvokeAsync(args);