Name: DotMake.CommandLine
Author: dotmake

DotMake.CommandLine v2.8.2 — nugetz

dotnet add package DotMake.CommandLine

PM> Install-Package DotMake.CommandLine

using System;
using DotMake.CommandLine;

// Add this single line to run you app!
Cli.Run<RootCliCommand>(args);

// Create a simple class like this to define your root command:
[CliCommand(Description = "A root cli command")]
public class RootCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";
 
    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }
 
    public void Run()
    {
        Console.WriteLine($@"Handler for '{GetType().FullName}' is run:");
        Console.WriteLine($@"Value for {nameof(Option1)} property is '{Option1}'");
        Console.WriteLine($@"Value for {nameof(Argument1)} property is '{Argument1}'");
        Console.WriteLine();
    }
}

await Cli.RunAsync<RootCliCommand>(args);

try
{
    Cli.Run<RootCliCommand>(args);
}
catch (Exception e)
{
    Console.WriteLine(@"Exception in main: {0}", e.Message);
}

Cli.Run<RootCliCommand>(args, new CliSettings { EnableDefaultExceptionHandler = true });

var result = Cli.Parse<RootCliCommand>(args);
var rootCliCommand = result.Bind<RootCliCommand>();

var result = Cli.Parse<RootCliCommand>(args);
if (result.ParseResult.Errors.Count > 0)
{

}

using System;
using DotMake.CommandLine;

Cli.Run(([CliArgument]string arg1, bool opt1) =>
{
    Console.WriteLine($@"Value for {nameof(arg1)} parameter is '{arg1}'");
    Console.WriteLine($@"Value for {nameof(opt1)} parameter is '{opt1}'");
});

dotnet publish -c Release -r win-x64 -p:PublishTrimmed=true;PublishSingleFile=true

dotnet publish -c Release -r win-x64 -f net8.0 -p:PublishTrimmed=true;PublishSingleFile=true;TargetFrameworks=net8.0

dotnet publish -c Release -r win-x64 -p:PublishAot=true

dotnet publish -c Release -r win-x64 -f net8.0 -p:PublishAot=true;TargetFrameworks=net8.0

DotMake Command-Line TestApp v2.5.0
Copyright © 2023-2025 DotMake

A root cli command

Usage:
  TestApp <argument-1> [options]

Arguments:
  <argument-1>  Description for Argument1 [required]

Options:
  -o1, --option-1  Description for Option1 [default: DefaultForOption1]
  -?, -h, --help   Show help and usage information
  -v, --version    Show version information

First the following suffixes are stripped out from class and property names:
- For commands: "RootCliCommand", "RootCommand", "SubCliCommand", "SubCommand", "CliCommand", "Command", "Cli"
- For directives: "Directive" or above command suffixes followed by "Directive", e.g. "CommandDirective"
- For options: "Option" or above command suffixes followed by "Option", e.g. "CommandOption"
- For arguments: "Argument" or above command suffixes followed by "Argument", e.g. "CommandArgument"
Then the names are converted to kebab-case.
(e.g. Info -> info,ServerPort -> server-port, Option1 -> option-1)
This can be changed by setting [CliCommand].NameCasingConvention property to one of the following values:
- CliNameCasingConvention.None
- CliNameCasingConvention.LowerCase
- CliNameCasingConvention.UpperCase
- CliNameCasingConvention.TitleCase
- CliNameCasingConvention.PascalCase
- CliNameCasingConvention.CamelCase
- CliNameCasingConvention.KebabCase
- CliNameCasingConvention.SnakeCase
For options, double hyphen/dash prefix is added to the name.
(e.g. Info -> --info,ServerPort -> --server-port, Option1 -> --option-1)
This can be changed by setting [CliCommand].NamePrefixConvention property (default: DoubleHyphen) to one of the following values:
- CliNamePrefixConvention.None
- CliNamePrefixConvention.SingleHyphen
- CliNamePrefixConvention.DoubleHyphen
- CliNamePrefixConvention.ForwardSlash
When you set a specific name via [CliXXX].Name property, that will be used instead of a auto-generated name.
For options, if you don't specify a prefix, it will be prefixed automatically according to [CliCommand].NamePrefixConvention
(e.g. --option, -option or /option) unless it's set to CliNamePrefixConvention.None.

Auto-generated names can be disabled for all or specific CLI symbol types via [CliCommand].NameAutoGenerate.
For commands and options, a short form alias is automatically added. First letters of every word in the name will be used to create short form to reduce conflicts. These first letters are converted according to [CliCommand].NameCasingConvention property.
(e.g. Info -> i,ServerPort -> sp, Option1 -> o1)

For options, single hyphen/dash prefix is added to the short form.
(e.g. Info -> -i,ServerPort -> -sp, Option1 -> -o1)
This can be changed via [CliCommand].ShortFormPrefixConvention property (default: SingleHyphen).

When you set a specific alias via [CliXXX].Alias property, that will be used instead of a auto-generated short form alias.
For options, if you don't specify a prefix, it will be prefixed automatically according to [CliCommand].ShortFormPrefixConvention
(e.g. -o or --o or /o) unless it's set to CliNamePrefixConvention.None.

Auto-generated short form aliases can be disabled for all or specific CLI symbol types via [CliCommand].ShortFormAutoGenerate.

using System;
using DotMake.CommandLine;
 
[CliCommand(
    Description = "A cli command with snake_case name casing and forward slash prefix conventions",
    NameCasingConvention = CliNameCasingConvention.SnakeCase,
    NamePrefixConvention = CliNamePrefixConvention.ForwardSlash,
    ShortFormPrefixConvention = CliNamePrefixConvention.ForwardSlash
)]
public class RootSnakeSlashCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";
 
    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }
 
    public void Run()
    {
        Console.WriteLine($@"Handler for '{GetType().FullName}' is run:");
        Console.WriteLine($@"Value for {nameof(Option1)} property is '{Option1}'");
        Console.WriteLine($@"Value for {nameof(Argument1)} property is '{Argument1}'");
        Console.WriteLine();
    }
}

DotMake Command-Line TestApp v2.5.0
Copyright © 2023-2025 DotMake

A cli command with snake_case convention

Usage:
  TestApp <argument_1> [options]

Arguments:
  <argument_1>  Description for Argument1 [required]

Options:
  /o1, /option_1  Description for Option1 [default: DefaultForOption1]
  -?, -h, /help   Show help and usage information
  /v, /version    Show version information

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.Red });

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.DarkRed });

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.Green });

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.DarkGreen });

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.Blue });

Cli.Run<RootCliCommand>(args, new CliSettings { Theme = CliTheme.DarkBlue });

Cli.Run<RootCliCommand>(args, new CliSettings
{
    Theme = new CliTheme(CliTheme.Default)
    {
        HeadingCasing = CliNameCasingConvention.UpperCase,
        HeadingNoColon = true
    }
});

[CliCommand(Description = nameof(TestResources.CommandDescription))]
internal class LocalizedCliCommand
{
    [CliOption(Description = nameof(TestResources.OptionDescription))]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = nameof(TestResources.ArgumentDescription))]
    public string Argument1 { get; set; }

    public void Run()
    {
        Console.WriteLine($@"Handler for '{GetType().FullName}' is run:");
        Console.WriteLine($@"Value for {nameof(Option1)} property is '{Option1}'");
        Console.WriteLine($@"Value for {nameof(Argument1)} property is '{Argument1}'");
        Console.WriteLine();
    }
}

[CliCommand(Description = "A root cli command")]
public class HelpCliCommand
{
  [CliOption(Description = "Description for Option1")]
  public string Option1 { get; set; } = "DefaultForOption1";

  [CliArgument(Description = "Description for Argument1")]
  public string Argument1 { get; set; } = "DefaultForArgument1";

  [CliCommand(Description = "A sub cli command")]
  public class SubCliCommand
  {
      [CliArgument(Description = "Description for Argument2")]
      public string Argument2 { get; set; } = "DefaultForArgument2";

      public void Run(CliContext context)
      {
          if (context.IsEmptyCommand())
              context.ShowHelp();
          else
              context.ShowValues();
      }
  }
}

/*
    Command hierarchy in below example is:
        
     TestApp
     └╴level-1
       └╴level-2
*/

[CliCommand(Description = "A root cli command with nested children")]
public class RootWithNestedChildrenCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; } = "DefaultForArgument1";

    public void Run(CliContext context)
    {
        if (context.IsEmptyCommand())
            context.ShowHierarchy();
        else
            context.ShowValues();
    }

    [CliCommand(Description = "A nested level 1 sub-command")]
    public class Level1SubCliCommand
    {
        [CliOption(Description = "Description for Option1")]
        public string Option1 { get; set; } = "DefaultForOption1";

        [CliArgument(Description = "Description for Argument1")]
        public string Argument1 { get; set; }

        public void Run(CliContext context)
        {
            context.ShowValues();
        }

        [CliCommand(Description = "A nested level 2 sub-command")]
        public class Level2SubCliCommand
        {
            [CliOption(Description = "Description for Option1")]
            public string Option1 { get; set; } = "DefaultForOption1";

            [CliArgument(Description = "Description for Argument1")]
            public string Argument1 { get; set; }

            public void Run(CliContext context)
            {
                context.ShowValues();
            }
        }
    }
}

/*
    Command hierarchy in below example is:

     TestApp
     └╴external-level-1
       └╴external-level-2
*/

[CliCommand(
    Description = "A root cli command with external children",
    Children = new []
    {
        typeof(ExternalLevel1SubCliCommand)
    }
)]
public class RootWithExternalChildrenCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; } = "DefaultForArgument1";

    public void Run(CliContext context)
    {
        if (context.IsEmptyCommand())
            context.ShowHierarchy();
        else
            context.ShowValues();
    }
}

[CliCommand(
    Description = "An external level 1 sub-command",
    Children = new[]
    {
        typeof(ExternalLevel2SubCliCommand)
    }
)]
public class ExternalLevel1SubCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }
}

[CliCommand(Description = "An external level 2 sub-command")]
public class ExternalLevel2SubCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }
}

/*
    Command hierarchy in below example is:

     TestApp
     └╴external-level-1-with-parent
       └╴external-level-2-with-parent
*/

[CliCommand(
    Description = "A root cli command with external children"
)]
public class RootAsExternalParentCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; } = "DefaultForArgument1";

    public void Run(CliContext context)
    {
        if (context.IsEmptyCommand())
            context.ShowHierarchy();
        else
            context.ShowValues();
    }
}

[CliCommand(
    Description = "An external level 1 sub-command",
    Parent = typeof(RootAsExternalParentCliCommand)
)]
public class ExternalLevel1WithParentSubCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }
}

[CliCommand(
    Description = "An external level 2 sub-command",
    Parent = typeof(ExternalLevel1WithParentSubCliCommand)
)]
public class ExternalLevel2WithParentSubCliCommand
{
    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }
}

 TestApp
 ├╴external-level-1-with-nested
 │ └╴level-2
 └╴level_1
   └╴external_level_2_with_nested
     └╴level_3

// Sub-commands can get a reference to the parent command by adding a property of the parent command type.

[CliCommand(Description = "A root cli command with children that can access parent commands")]
public class ParentCommandAccessorCliCommand
{
    [CliOption(
        Description = "This is a global option (Recursive option on the root command), it can appear anywhere on the command line",
        Recursive = true)]
    public string GlobalOption1 { get; set; } = "DefaultForGlobalOption1";

    [CliArgument(Description = "Description for RootArgument1")]
    public string RootArgument1 { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }

    [CliCommand(Description = "A nested level 1 sub-command which accesses the root command")]
    public class Level1SubCliCommand
    {
        [CliOption(
            Description = "This is global for all sub commands (it can appear anywhere after the level-1 verb)",
            Recursive = true)]
        public string Level1RecursiveOption1 { get; set; } = "DefaultForLevel1RecusiveOption1";

        [CliArgument(Description = "Description for Argument1")]
        public string Argument1 { get; set; }

        // The parent command gets automatically injected
        public ParentCommandAccessorCliCommand RootCommand { get; set; }

        public void Run(CliContext context)
        {
            context.ShowValues();
        }

        [CliCommand(Description = "A nested level 2 sub-command which accesses its parent commands")]
        public class Level2SubCliCommand
        {
            [CliOption(Description = "Description for Option1")]
            public string Option1 { get; set; } = "DefaultForOption1";

            [CliArgument(Description = "Description for Argument1")]
            public string Argument1 { get; set; }

            // All ancestor commands gets injected
            public ParentCommandAccessorCliCommand RootCommand { get; set; }
            public Level1SubCliCommand ParentCommand { get; set; }

            public void Run(CliContext context)
            {
                context.ShowValues();

                Console.WriteLine();
                Console.WriteLine(@$"Level1RecursiveOption1 = {ParentCommand.Level1RecursiveOption1}");
                Console.WriteLine(@$"parent Argument1 = {ParentCommand.Argument1}");
                Console.WriteLine(@$"GlobalOption1 = {RootCommand.GlobalOption1}");
                Console.WriteLine(@$"RootArgument1 = {RootCommand.RootArgument1}");
            }
        }
    }
}

[CliCommand(Description = "A root cli command")]
public class RootCliCommand
{
    //This will be non-null only when the called command was this sub-command
    //For example you can check sub-command accessors for null to determine
    //which one was called
    public SubCliCommand SubCliCommandAccessor { get; set; }

    [CliCommand(Description = "A sub-command")]
    public class SubCliCommand
    {
        //This will be always non-null because if sub-command was called,
        //its parent-command should also have been called
        public RootCliCommand RootCliCommandAccessor { get; set; }
    }
}

[CliCommand]
public class InheritanceCliCommand : CredentialCommandBase, IDepartmentCommand
{
    public string Department { get; set; } = "Accounting";
}

public abstract class CredentialCommandBase
{
    [CliOption(Description = "Username of the identity performing the command")]
    public string Username { get; set; } = "admin";

    [CliOption(Description = "Password of the identity performing the command")]
    public string Password { get; set; }

    public void Run()
    {
        Console.WriteLine($@"I am {Username}");
    }
}

public interface IDepartmentCommand
{
    [CliOption(Description = "Department of the identity performing the command (interface)")]
    string Department { get; set; }
}

[CliCommand]
public interface IOptionsGroup1
{
    [CliOption(Description = "Username of the identity performing the command")]
    public string Username { get; set; }

    [CliOption(Description = "Password of the identity performing the command")]
    public string Password { get; set; }
}

public interface IOptionsGroup2
{
    [CliOption(Description = "Department of the identity performing the command (interface)")]
    string Department { get; set; }
}

public class MyCliCommand : IOptionsGroup1, IOptionsGroup2
{
    public string Username { get; set; } = "admin";

    public string Password { get; set; }

    public string Department { get; set; } = "Accounting";
}

public class My2CliCommand : IOptionsGroup1
{
    public string Username { get; set; } = "admin";

    public string Password { get; set; }
}

dotnet tool update dotnet-suggest --verbosity quiet --global
                                  ^---------^       ^------^

msbuild /version
        ^------^

dotnet build -v quiet
dotnet build -v=quiet
dotnet build -v:quiet

myapp -vquiet
myapp -v quiet

dotnet tool update dotnet-suggest --verbosity quiet --global
                                              ^---^

dotnet build myapp.csproj
             ^----------^

dotnet tool update dotnet-suggest --global
                                  ^------^

dotnet tool update dotnet-suggest --global true
                                  ^-----------^

dotnet build --verbosity silent

Cannot parse argument 'silent' for option '-v' as expected type 'Microsoft.DotNet.Cli.VerbosityOptions'. Did you mean one of the following?
Detailed
Diagnostic
Minimal
Normal
Quiet

[CliOption]
public string Opt1 { get; set; } // => Required because default value is null

[CliOption]
public bool Opt2 { get; set; } // => Optional because default value is non-null

[CliOption]
public bool? Opt3 { get; set; } // => Required because default value is null

[CliOption(Required = false)]
public string Opt1 { get; set; } // => Optional because attribute has `Required = false`

[CliOption(Required = false)]
public bool? Opt3 { get; set; } // => Optional because attribute has `Required = false`

TestApp.exe NewValueForArgument1

dotnet run -- NewValueForArgument1

Handler for 'TestApp.Commands.RootCliCommand' is run:
Value for Option1 property is 'DefaultForOption1'
Value for Argument1 property is 'NewValueForArgument1'

var result = Cli.Parse<RootCliCommand>(args);

//Bind returns null if the command line input does not contain
//the indicated definition class (as self or as a parent)
var subCommand = result.Bind<SubCliCommand>();
//unless you set new returnEmpty parameter to true
var subCommand2 = result.Bind<SubCliCommand>(true);

//You can get an object for called command
//without specifying the definition class
var command = result.BindCalled();
if (command is SubCliCommand subCommand3)
{

}
//Or get an array of objects for all contained commands
//(self and parents) without specifying the definition class
var commands = result.BindAll();
if (commands[0] is SubCliCommand subCommand4)
{

}

//You can check if the command line input is
//for the indicated definition class
if (result.IsCalled<SubCliCommand>())
{

}
//You can check if the command line input contains
//the indicated definition class (as self or as a parent)
if (result.Contains<SubCliCommand>())
{

}

//You can create a new instance of the command definition class
//but without any binding. This is useful for example when you need to
//instantiate a definition class when using dependency injection.
var subCommand5 = result.Create<SubCliCommand>();

[CliCommand]
public class WriteFileCliCommand
{
    [CliArgument]
    public FileInfo OutputFile { get; set; }

    [CliOption]
    public List<string> Lines { get; set; }
}

Booleans (flags) - If true or false is passed for an option having a bool argument, it is parsed and bound as expected. But an option whose argument type is bool doesn't require an argument to be specified. The presence of the option token on the command line, with no argument following it, results in a value of true.
Enums - The values are bound by name, and the binding is case insensitive
Common CLR types:
- FileSystemInfo, FileInfo, DirectoryInfo
- int, long, short, uint, ulong, ushort
- double, float, decimal
- byte, sbyte
- DateTime, DateTimeOffset, TimeSpan, DateOnly, TimeOnly
- Guid
- Uri, IPAddress, IPEndPoint
Any type with a public constructor or a static Parse method with a string parameter (other parameters, if any, should be optional) - These types can be bound/parsed automatically even if they are wrapped with Enumerable or Nullable type.
[CliCommand] public class ArgumentConverterCliCommand { [CliOption] public ClassWithConstructor Opt { get; set; } [CliOption(AllowMultipleArgumentsPerToken = true)] public ClassWithConstructor[] OptArray { get; set; } [CliOption] public CustomStruct? OptNullable { get; set; } [CliOption] public IEnumerable<ClassWithConstructor> OptEnumerable { get; set; } [CliOption] public List<ClassWithConstructor> OptList { get; set; } [CliOption] public CustomList<ClassWithConstructor> OptCustomList { get; set; } [CliArgument] public IEnumerable<ClassWithParser> Arg { get; set; } } public class ClassWithConstructor { private readonly string value; public ClassWithConstructor(string value) { this.value = value; } public override string ToString() { return value; } } public class ClassWithParser { private string value; public override string ToString() { return value; } public static ClassWithParser Parse(string value) { var instance = new ClassWithParser(); instance.value = value; return instance; } } public struct CustomStruct { private readonly string value; public CustomStruct(string value) { this.value = value; } public override string ToString() { return value; } }
Arrays, lists, collections:
- Any type that implements IEnumerable<T> and has a public constructor with a IEnumerable<T> or IList<T> parameter (other parameters, if any, should be optional). CLR collection types already satisfy this condition.
- If type is generic IEnumerable<T>, IList<T>, ICollection<T> interfaces itself, array T[] will be used to create an instance.
- If type is non-generic IEnumerable, IList, ICollection interfaces itself, array string[] will be used to create an instance.
[CliCommand] public class EnumerableCliCommand { [CliOption] public IEnumerable<int> OptEnumerable { get; set; } [CliOption] public List<string> OptList { get; set; } [CliOption(AllowMultipleArgumentsPerToken = true)] public FileAccess[] OptEnumArray { get; set; } [CliOption] public Collection<string> OptCollection { get; set; } [CliOption] public HashSet<string> OptHashSet { get; set; } [CliOption] public Queue<FileInfo> OptQueue { get; set; } [CliOption] public CustomList<string> OptCustomList { get; set; } [CliArgument] public IList ArgIList { get; set; } } public class CustomList<T> : List<T> { public CustomList(IEnumerable<T> items) : base(items) { } }

[CliCommand]
public class ValidationCliCommand
{
    [CliOption(Required = false, ValidationRules = CliValidationRules.ExistingFile)]
    public FileInfo OptFile1 { get; set; }

    [CliOption(Required = false, ValidationRules = CliValidationRules.NonExistingFile | CliValidationRules.LegalPath)]
    public string OptFile2 { get; set; }

    [CliOption(Required = false, ValidationPattern = @"(?i)^[a-z]+$")]
    public string OptPattern1 { get; set; }

    [CliOption(Required = false, ValidationPattern = @"(?i)^[a-z]+$", ValidationMessage = "Custom error message")]
    public string OptPattern2 { get; set; }

    [CliOption(Required = false, ValidationRules = CliValidationRules.LegalUrl)]
    public string OptUrl { get; set; }

    [CliOption(Required = false, ValidationRules = CliValidationRules.LegalUri)]
    public string OptUri { get; set; }

    [CliArgument(Required = false, ValidationRules = CliValidationRules.LegalFileName)]
    public string OptFileName { get; set; }

    public void Run(CliContext context)
    {
        context.ShowValues();
    }
}

using System;
using System.Collections.Generic;
using System.CommandLine.Completions;
using System.Linq;
using DotMake.CommandLine;

[CliCommand(Description = "A root cli command with completions for options and arguments")]
public class GetCompletionsCliCommand : ICliGetCompletions
{
    [CliOption(Description = "Description for DateOption")]
    public DateTime DateOption { get; set; }

    [CliArgument(Description = "Description for FruitArgument")]
    public string FruitArgument { get; set; } = "DefaultForFruitArgument";

    public void Run(CliContext context)
    {
        if (context.IsEmptyCommand())
            context.ShowHelp();
        else
            context.ShowValues();
    }

    public IEnumerable<CompletionItem> GetCompletions(string propertyName, CompletionContext completionContext)
    {
        switch (propertyName)
        {
            case nameof(DateOption):
                var today = DateTime.Today;
                var dates = new List<CompletionItem>();

                foreach (var i in Enumerable.Range(1, 7))
                {
                    var date = today.AddDays(i);
                    dates.Add(new CompletionItem(
                        label: date.ToShortDateString(),
                        sortText: $"{i:2}"));
                }

                return dates;

            case nameof(FruitArgument):
                return new [] { "apple", "orange", "banana" }
                    .Select(value => new CompletionItem(value));
        }

        return Enumerable.Empty<CompletionItem>();
    }
}

DotMake Command-Line TestApp v2.5.0
Copyright © 2023-2025 DotMake

A root cli command with completions for options and arguments

Usage:
  TestApp [<fruit>] [options]

Arguments:
  <apple|banana|orange>  Description for FruitArgument [default: DefaultForFruitArgument]

Options:
  -d, --date                                                  Description for DateOption [default: 1.01.0001 00:00:00]
  <22.04.2025|23.04.2025|24.04.2025|25.04.2025|26.04.2025|27
  .04.2025|28.04.2025>
  -?, -h, --help                                              Show help and usage information
  -v, --version                                               Show version information

dotnet add package Microsoft.Extensions.DependencyInjection

PM> Install-Package Microsoft.Extensions.DependencyInjection

using DotMake.CommandLine;
using Microsoft.Extensions.DependencyInjection;

Cli.Ext.ConfigureServices(services =>
{
    services.AddTransient<TransientClass>();
    services.AddScoped<ScopedClass>();
    services.AddSingleton<SingletonClass>();
});

Cli.Run<RootCliCommand>();

[CliCommand(Description = "A root cli command with dependency injection")]
public class RootCliCommand
{
    private readonly TransientClass transientDisposable;
    private readonly ScopedClass scopedDisposable;
    private readonly SingletonClass singletonDisposable;

    public RootCliCommand(
        TransientClass transientDisposable,
        ScopedClass scopedDisposable,
        SingletonClass singletonDisposable
    )
    {
        this.transientDisposable = transientDisposable;
        this.scopedDisposable = scopedDisposable;
        this.singletonDisposable = singletonDisposable;
    }

    [CliOption(Description = "Description for Option1")]
    public string Option1 { get; set; } = "DefaultForOption1";

    [CliArgument(Description = "Description for Argument1")]
    public string Argument1 { get; set; }

    public void Run()
    {
        Console.WriteLine($@"Handler for '{GetType().FullName}' is run:");
        Console.WriteLine($@"Value for {nameof(Option1)} property is '{Option1}'");
        Console.WriteLine($@"Value for {nameof(Argument1)} property is '{Argument1}'");
        Console.WriteLine();

        Console.WriteLine($"Instance for {transientDisposable.Name} is available");
        Console.WriteLine($"Instance for {scopedDisposable.Name} is available");
        Console.WriteLine($"Instance for {singletonDisposable.Name} is available");
        Console.WriteLine();
    }
}

public sealed class TransientClass : IDisposable
{
    public string Name => nameof(TransientClass);

    public void Dispose() => Console.WriteLine($"{nameof(TransientClass)}.Dispose()");
}

public sealed class ScopedClass : IDisposable
{
    public string Name => nameof(ScopedClass);

    public void Dispose() => Console.WriteLine($"{nameof(ScopedClass)}.Dispose()");
}

public sealed class SingletonClass : IDisposable
{
    public string Name => nameof(SingletonClass);

    public void Dispose() => Console.WriteLine($"{nameof(SingletonClass)}.Dispose()");
}

dotnet add package Microsoft.Extensions.DependencyInjection.Abstractions

PM> Install-Package Microsoft.Extensions.DependencyInjection.Abstractions

using DotMake.CommandLine;
using Autofac.Core;
using Autofac.Core.Registration;

var cb = new ContainerBuilder();
cb.RegisterType<object>();
var container = cb.Build();

Cli.Ext.SetServiceProvider(container);

Cli.Run<RootCliCommand>();

dotnet build --no-restore --output ./build-output/
dotnet @sample1.rsp
dotnet build @sample2.rsp --output ./build-output/

build
--no-restore 
--output
./build-output/

--no-restore

dotnet [diagram] build --no-restore --output ./build-output/
       ^-------^

[ dotnet [ build [ --no-restore <True> ] [ --output <./build-output/> ] ] ]

myapp [directive:value]

myapp [directive:value1] [directive:value2]

[CliCommand(Description = "A root cli command with directives")]
public class DirectiveCliCommand
{
    [CliDirective]
    public bool Debug { get; set; }

    [CliDirective]
    public string Directive2 { get; set; }

    [CliDirective]
    public string[] Vars { get; set; }

    public void Run(CliContext context)
    {
        if (context.IsEmpty())
            context.ShowHelp();
        else
        {
            Console.WriteLine($"Directive '{nameof(Debug)}' = {StringExtensions.FormatValue(Debug)}");
            Console.WriteLine($"Directive '{nameof(Directive2)}' = {StringExtensions.FormatValue(Directive2)}");
            Console.WriteLine($"Directive '{nameof(Vars)}' = {StringExtensions.FormatValue(Vars)}");
        }
    }
}

src\TestApp\bin\Debug\net8.0>TestApp [debug] [directive-2:val1] [vars:val2] [vars:val3]
Directive 'Debug' = true
Directive 'Directive2' = "val1"
Directive 'Vars' = ["val2", "val3"]

myapp [diagram] --delay not-an-int --interactive --file filename.txt extra

![ myapp [ --delay !<not-an-int> ] [ --interactive <True> ] [ --file <filename.txt> ] *[ --fgcolor <White> ] ]   ???--> extra

dotnet [suggest] buil

build
build-server
msbuild

myapp [env:key=value]

myapp [env:key1=value1] [env:key2=value2]

1. Build TestApp.cmd
2. Build Nuget Package.cmd
3.1. Build TestApp.Nuget.cmd
3.2. Build TestApp.NugetDI.cmd
3.3. Build TestApp.NugetAot.cmd
4. Build Api Docs WebSite.cmd

TestApp-net472
TestApp-net8.0

DotMake.CommandLine.2.5.6.nupkg

TestApp.Nuget-net472
TestApp.Nuget-net8.0

TestApp.NugetDI-net472
TestApp.NugetDI-net8.0

TestApp.NugetAot-win-x64-native
TestApp.NugetAot-win-x64-trimmed

dotmake/DotMake.CommandLinev2.8.2

Get Started

Readme

DotMake Command-Line

Getting started

Prerequisites

Usage

Class-based model

Summary

Delegate-based model

Summary

Trim self-contained deployment

Native AOT deployment

Help output

Themes

Localization

Triggering help

Commands

Root commands

Subcommands

Command Hierarchy

Use `Children` property of `[CliCommand]` attribute to specify array of `typeof` child classes:

Or use `Parent` property of `[CliCommand]` attribute to specify `typeof` parent class:

Accessing parent commands

Command Inheritance

Options

Arguments

Model binding

Manual binding

Supported types

Validation

Completions

Dependency Injection

Response files

Directives

The `[diagram]` directive

The `[suggest]` directive

The `[env]` directive

Building

Additional documentation

dotmake/DotMake.CommandLinev2.8.2

Get Started

Readme

DotMake Command-Line

Getting started

Prerequisites

Usage

Class-based model

Summary

Delegate-based model

Summary

Trim self-contained deployment

Native AOT deployment

Help output

Themes

Localization

Triggering help

Commands

Root commands

Subcommands

Command Hierarchy

Use Children property of [CliCommand] attribute to specify array of typeof child classes:

Or use Parent property of [CliCommand] attribute to specify typeof parent class:

Accessing parent commands

Command Inheritance

Options

Arguments

Model binding

Manual binding

Supported types

Validation

Completions

Dependency Injection

Response files

Directives

The [diagram] directive

The [suggest] directive

The [env] directive

Building

Additional documentation

Use `Children` property of `[CliCommand]` attribute to specify array of `typeof` child classes:

Or use `Parent` property of `[CliCommand]` attribute to specify `typeof` parent class:

The `[diagram]` directive

The `[suggest]` directive

The `[env]` directive