Update version

Closes #38
Closes #24

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+github: Tyrrrz
+patreon: Tyrrrz
+custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']

.github/workflows/CD.yml

@@ -0,0 +1,25 @@
+name: CD
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1.4.0
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Pack
+      run: dotnet pack CliFx --configuration Release
+
+    - name: Deploy
+      run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{secrets.NUGET_TOKEN}}

.github/workflows/CI.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1.4.0
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Build & test
+      run: dotnet test --configuration Release
+
+    - name: Upload coverage
+      uses: codecov/codecov-action@v1.0.5
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: CliFx.Tests/bin/Release/Coverage.xml

.gitignore

@@ -143,6 +143,7 @@ _TeamCity*
 _NCrunch_*
 .*crunch*.local.xml
 nCrunchTemp_*
+.ncrunchsolution
 
 # MightyMoose
 *.mm.*

Changelog.md

@@ -0,0 +1,5 @@
+### v1.1 (16-Mar-2020)
+
+- Changed `IConsole` interface (and as a result, `SystemConsole` and `VirtualConsole`) to support writing binary data. Instead of `TextReader`/`TextWriter` instances, the streams are now exposed as `StreamReader`/`StreamWriter` which provide the `BaseStream` property that allows raw access. Existing usages inside commands should remain the same because `StreamReader`/`StreamWriter` are compatible with their base classes `TextReader`/`TextWriter`, but if you were using `VirtualConsole` in tests, you may have to update it to the new API. Refer to the readme for more info.
+- Changed argument binding behavior so that an error is produced if the user provides an argument that doesn't match with any parameter or option. This is done in order to improve user experience, as otherwise the user may make a typo without knowing that their input wasn't taken into account.
+- Changed argument binding behavior so that options can be set to multiple argument values while specifying them with mixed naming. For example, `--option value1 -o value2 --option value3` would result in the option being set to corresponding three values, assuming `--option` and `-o` match with the same option.

CliFx.Benchmarks/Benchmarks.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Running;
+using CliFx.Benchmarks.Commands;
+using CommandLine;
+
+namespace CliFx.Benchmarks
+{
+    [SimpleJob]
+    [RankColumn]
+    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+    public class Benchmarks
+    {
+        private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
+
+        [Benchmark(Description = "CliFx", Baseline = true)]
+        public async ValueTask<int> ExecuteWithCliFx() =>
+            await new CliApplicationBuilder().AddCommand(typeof(CliFxCommand)).Build().RunAsync(Arguments, new Dictionary<string, string>());
+
+        [Benchmark(Description = "System.CommandLine")]
+        public async Task<int> ExecuteWithSystemCommandLine() =>
+            await new SystemCommandLineCommand().ExecuteAsync(Arguments);
+
+        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
+        public int ExecuteWithMcMaster() =>
+            McMaster.Extensions.CommandLineUtils.CommandLineApplication.Execute<McMasterCommand>(Arguments);
+
+        [Benchmark(Description = "CommandLineParser")]
+        public void ExecuteWithCommandLineParser() =>
+            new Parser()
+                .ParseArguments(Arguments, typeof(CommandLineParserCommand))
+                .WithParsed<CommandLineParserCommand>(c => c.Execute());
+
+        [Benchmark(Description = "PowerArgs")]
+        public void ExecuteWithPowerArgs() =>
+            PowerArgs.Args.InvokeMain<PowerArgsCommand>(Arguments);
+
+        [Benchmark(Description = "Clipr")]
+        public void ExecuteWithClipr() =>
+            clipr.CliParser.Parse<CliprCommand>(Arguments).Execute();
+
+        [Benchmark(Description = "Cocona")]
+        public void ExecuteWithCocona() =>
+            Cocona.CoconaApp.Run<CoconaCommand>(Arguments);
+
+        public static void Main() =>
+            BenchmarkRunner.Run<Benchmarks>(DefaultConfig.Instance.With(ConfigOptions.DisableOptimizationsValidator));
+    }
+}

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="clipr" Version="1.6.1" />
+    <PackageReference Include="Cocona" Version="1.3.0" />
+    <PackageReference Include="CommandLineParser" Version="2.7.82" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.6.0" />
+    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19317.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CliFx\CliFx.csproj" />
+  </ItemGroup>
+
+</Project>

CliFx.Benchmarks/Commands/CliFxCommand.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Benchmarks.Commands
+{
+    [Command]
+    public class CliFxCommand : ICommand
+    {
+        [CommandOption("str", 's')]
+        public string? StrOption { get; set; }
+
+        [CommandOption("int", 'i')]
+        public int IntOption { get; set; }
+
+        [CommandOption("bool", 'b')]
+        public bool BoolOption { get; set; }
+
+        public ValueTask ExecuteAsync(IConsole console) => default;
+    }
+}

CliFx.Benchmarks/Commands/CliprCommand.cs

@@ -0,0 +1,20 @@
+using clipr;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class CliprCommand
+    {
+        [NamedArgument('s', "str")]
+        public string? StrOption { get; set; }
+
+        [NamedArgument('i', "int")]
+        public int IntOption { get; set; }
+
+        [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
+        public bool BoolOption { get; set; }
+
+        public void Execute()
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/CoconaCommand.cs

@@ -0,0 +1,17 @@
+using Cocona;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class CoconaCommand
+    {
+        public void Execute(
+            [Option("str", new []{'s'})]
+            string? strOption,
+            [Option("int", new []{'i'})]
+            int intOption,
+            [Option("bool", new []{'b'})]
+            bool boolOption)
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/CommandLineParserCommand.cs

@@ -0,0 +1,20 @@
+using CommandLine;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class CommandLineParserCommand
+    {
+        [Option('s', "str")]
+        public string? StrOption { get; set; }
+
+        [Option('i', "int")]
+        public int IntOption { get; set; }
+
+        [Option('b', "bool")]
+        public bool BoolOption { get; set; }
+
+        public void Execute()
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/McMasterCommand.cs

@@ -0,0 +1,18 @@
+using McMaster.Extensions.CommandLineUtils;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class McMasterCommand
+    {
+        [Option("--str|-s")]
+        public string? StrOption { get; set; }
+
+        [Option("--int|-i")]
+        public int IntOption { get; set; }
+
+        [Option("--bool|-b")]
+        public bool BoolOption { get; set; }
+
+        public int OnExecute() => 0;
+    }
+}

CliFx.Benchmarks/Commands/PowerArgsCommand.cs

@@ -0,0 +1,20 @@
+using PowerArgs;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class PowerArgsCommand
+    {
+        [ArgShortcut("--str"), ArgShortcut("-s")]
+        public string? StrOption { get; set; }
+
+        [ArgShortcut("--int"), ArgShortcut("-i")]
+        public int IntOption { get; set; }
+
+        [ArgShortcut("--bool"), ArgShortcut("-b")]
+        public bool BoolOption { get; set; }
+
+        public void Main()
+        {
+        }
+    }
+}

CliFx.Benchmarks/Commands/SystemCommandLineCommand.cs

@@ -0,0 +1,34 @@
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.Threading.Tasks;
+
+namespace CliFx.Benchmarks.Commands
+{
+    public class SystemCommandLineCommand
+    {
+        public static int ExecuteHandler(string s, int i, bool b) => 0;
+
+        public Task<int> ExecuteAsync(string[] args)
+        {
+            var command = new RootCommand
+            {
+                new Option(new[] {"--str", "-s"})
+                {
+                    Argument = new Argument<string?>()
+                },
+                new Option(new[] {"--int", "-i"})
+                {
+                    Argument = new Argument<int>()
+                },
+                new Option(new[] {"--bool", "-b"})
+                {
+                    Argument = new Argument<bool>()
+                }
+            };
+
+            command.Handler = CommandHandler.Create(typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler)));
+
+            return command.InvokeAsync(args);
+        }
+    }
+}

CliFx.Demo/CliFx.Demo.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CliFx\CliFx.csproj" />
+  </ItemGroup>
+
+</Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Demo.Internal;
+using CliFx.Demo.Models;
+using CliFx.Demo.Services;
+using CliFx.Exceptions;
+
+namespace CliFx.Demo.Commands
+{
+    [Command("book add", Description = "Add a book to the library.")]
+    public partial class BookAddCommand : ICommand
+    {
+        private readonly LibraryService _libraryService;
+
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
+        public string Title { get; set; } = "";
+
+        [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
+        public string Author { get; set; } = "";
+
+        [CommandOption("published", 'p', Description = "Book publish date.")]
+        public DateTimeOffset Published { get; set; } = CreateRandomDate();
+
+        [CommandOption("isbn", 'n', Description = "Book ISBN.")]
+        public Isbn Isbn { get; set; } = CreateRandomIsbn();
+
+        public BookAddCommand(LibraryService libraryService)
+        {
+            _libraryService = libraryService;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            if (_libraryService.GetBook(Title) != null)
+                throw new CommandException("Book already exists.", 1);
+
+            var book = new Book(Title, Author, Published, Isbn);
+            _libraryService.AddBook(book);
+
+            console.Output.WriteLine("Book added.");
+            console.RenderBook(book);
+
+            return default;
+        }
+    }
+
+    public partial class BookAddCommand
+    {
+        private static readonly Random Random = new Random();
+
+        private static DateTimeOffset CreateRandomDate() => new DateTimeOffset(
+            Random.Next(1800, 2020),
+            Random.Next(1, 12),
+            Random.Next(1, 28),
+            Random.Next(1, 23),
+            Random.Next(1, 59),
+            Random.Next(1, 59),
+            TimeSpan.Zero);
+
+        private static Isbn CreateRandomIsbn() => new Isbn(
+            Random.Next(0, 999),
+            Random.Next(0, 99),
+            Random.Next(0, 99999),
+            Random.Next(0, 99),
+            Random.Next(0, 9));
+    }
+}

CliFx.Demo/Commands/BookCommand.cs

@@ -0,0 +1,34 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Demo.Internal;
+using CliFx.Demo.Services;
+using CliFx.Exceptions;
+
+namespace CliFx.Demo.Commands
+{
+    [Command("book", Description = "View, list, add or remove books.")]
+    public class BookCommand : ICommand
+    {
+        private readonly LibraryService _libraryService;
+
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
+        public string Title { get; set; } = "";
+
+        public BookCommand(LibraryService libraryService)
+        {
+            _libraryService = libraryService;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var book = _libraryService.GetBook(Title);
+
+            if (book == null)
+                throw new CommandException("Book not found.", 1);
+
+            console.RenderBook(book);
+
+            return default;
+        }
+    }
+}

CliFx.Demo/Commands/BookListCommand.cs

@@ -0,0 +1,37 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Demo.Internal;
+using CliFx.Demo.Services;
+
+namespace CliFx.Demo.Commands
+{
+    [Command("book list", Description = "List all books in the library.")]
+    public class BookListCommand : ICommand
+    {
+        private readonly LibraryService _libraryService;
+
+        public BookListCommand(LibraryService libraryService)
+        {
+            _libraryService = libraryService;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var library = _libraryService.GetLibrary();
+
+            var isFirst = true;
+            foreach (var book in library.Books)
+            {
+                // Margin
+                if (!isFirst)
+                    console.Output.WriteLine();
+                isFirst = false;
+
+                // Render book
+                console.RenderBook(book);
+            }
+
+            return default;
+        }
+    }
+}

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -0,0 +1,35 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Demo.Services;
+using CliFx.Exceptions;
+
+namespace CliFx.Demo.Commands
+{
+    [Command("book remove", Description = "Remove a book from the library.")]
+    public class BookRemoveCommand : ICommand
+    {
+        private readonly LibraryService _libraryService;
+
+        [CommandParameter(0, Name = "title", Description = "Book title.")]
+        public string Title { get; set; } = "";
+
+        public BookRemoveCommand(LibraryService libraryService)
+        {
+            _libraryService = libraryService;
+        }
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var book = _libraryService.GetBook(Title);
+
+            if (book == null)
+                throw new CommandException("Book not found.", 1);
+
+            _libraryService.RemoveBook(book);
+
+            console.Output.WriteLine($"Book {Title} removed.");
+
+            return default;
+        }
+    }
+}

CliFx.Demo/Internal/Extensions.cs

@@ -0,0 +1,29 @@
+using System;
+using CliFx.Demo.Models;
+
+namespace CliFx.Demo.Internal
+{
+    internal static class Extensions
+    {
+        public static void RenderBook(this IConsole console, Book book)
+        {
+            // Title
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Title));
+
+            // Author
+            console.Output.Write("  ");
+            console.Output.Write("Author: ");
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Author));
+
+            // Published
+            console.Output.Write("  ");
+            console.Output.Write("Published: ");
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine($"{book.Published:d}"));
+
+            // ISBN
+            console.Output.Write("  ");
+            console.Output.Write("ISBN: ");
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Isbn));
+        }
+    }
+}

CliFx.Demo/Models/Book.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace CliFx.Demo.Models
+{
+    public class Book
+    {
+        public string Title { get; }
+
+        public string Author { get; }
+
+        public DateTimeOffset Published { get; }
+
+        public Isbn Isbn { get; }
+
+        public Book(string title, string author, DateTimeOffset published, Isbn isbn)
+        {
+            Title = title;
+            Author = author;
+            Published = published;
+            Isbn = isbn;
+        }
+    }
+}

CliFx.Demo/Models/Extensions.cs

@@ -0,0 +1,22 @@
+using System.Linq;
+
+namespace CliFx.Demo.Models
+{
+    public static class Extensions
+    {
+        public static Library WithBook(this Library library, Book book)
+        {
+            var books = library.Books.ToList();
+            books.Add(book);
+
+            return new Library(books);
+        }
+
+        public static Library WithoutBook(this Library library, Book book)
+        {
+            var books = library.Books.Where(b => b != book).ToArray();
+
+            return new Library(books);
+        }
+    }
+}

CliFx.Demo/Models/Isbn.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace CliFx.Demo.Models
+{
+    public partial class Isbn
+    {
+        public int EanPrefix { get; }
+
+        public int RegistrationGroup { get; }
+
+        public int Registrant { get; }
+
+        public int Publication { get; }
+
+        public int CheckDigit { get; }
+
+        public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
+        {
+            EanPrefix = eanPrefix;
+            RegistrationGroup = registrationGroup;
+            Registrant = registrant;
+            Publication = publication;
+            CheckDigit = checkDigit;
+        }
+
+        public override string ToString() =>
+            $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+    }
+
+    public partial class Isbn
+    {
+        public static Isbn Parse(string value, IFormatProvider formatProvider)
+        {
+            var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
+
+            return new Isbn(
+                int.Parse(components[0], formatProvider),
+                int.Parse(components[1], formatProvider),
+                int.Parse(components[2], formatProvider),
+                int.Parse(components[3], formatProvider),
+                int.Parse(components[4], formatProvider)
+            );
+        }
+    }
+}

CliFx.Demo/Models/Library.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace CliFx.Demo.Models
+{
+    public partial class Library
+    {
+        public IReadOnlyList<Book> Books { get; }
+
+        public Library(IReadOnlyList<Book> books)
+        {
+            Books = books;
+        }
+    }
+
+    public partial class Library
+    {
+        public static Library Empty { get; } = new Library(Array.Empty<Book>());
+    }
+}

CliFx.Demo/Program.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Demo.Commands;
+using CliFx.Demo.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CliFx.Demo
+{
+    public static class Program
+    {
+        private static IServiceProvider GetServiceProvider()
+        {
+            // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
+            var services = new ServiceCollection();
+
+            // Register services
+            services.AddSingleton<LibraryService>();
+
+            // Register commands
+            services.AddTransient<BookCommand>();
+            services.AddTransient<BookAddCommand>();
+            services.AddTransient<BookRemoveCommand>();
+            services.AddTransient<BookListCommand>();
+
+            return services.BuildServiceProvider();
+        }
+
+        public static async Task<int> Main() =>
+            await new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .UseTypeActivator(GetServiceProvider().GetService)
+                .Build()
+                .RunAsync();
+    }
+}

CliFx.Demo/Readme.md

@@ -0,0 +1,7 @@
+# CliFx Demo Project
+
+Sample command line interface for managing a library of books.
+
+This demo project shows basic CliFx functionality such as command routing, argument parsing, autogenerated help text, and some other things.
+
+You can get a list of available commands by running `CliFx.Demo --help`.

CliFx.Demo/Services/LibraryService.cs

@@ -0,0 +1,42 @@
+using System.IO;
+using System.Linq;
+using CliFx.Demo.Models;
+using Newtonsoft.Json;
+
+namespace CliFx.Demo.Services
+{
+    public class LibraryService
+    {
+        private string StorageFilePath => Path.Combine(Directory.GetCurrentDirectory(), "Data.json");
+
+        private void StoreLibrary(Library library)
+        {
+            var data = JsonConvert.SerializeObject(library);
+            File.WriteAllText(StorageFilePath, data);
+        }
+
+        public Library GetLibrary()
+        {
+            if (!File.Exists(StorageFilePath))
+                return Library.Empty;
+
+            var data = File.ReadAllText(StorageFilePath);
+
+            return JsonConvert.DeserializeObject<Library>(data);
+        }
+
+        public Book? GetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
+
+        public void AddBook(Book book)
+        {
+            var updatedLibrary = GetLibrary().WithBook(book);
+            StoreLibrary(updatedLibrary);
+        }
+
+        public void RemoveBook(Book book)
+        {
+            var updatedLibrary = GetLibrary().WithoutBook(book);
+            StoreLibrary(updatedLibrary);
+        }
+    }
+}

CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net45</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

CliFx.Tests.Dummy/Commands/AddCommand.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Globalization;
-using CliFx.Attributes;
-using CliFx.Models;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command("add")]
-    public class AddCommand : Command
-    {
-        [CommandOption("a", IsRequired = true, Description = "Left operand.")]
-        public double A { get; set; }
-
-        [CommandOption("b", IsRequired = true, Description = "Right operand.")]
-        public double B { get; set; }
-
-        public override ExitCode Execute()
-        {
-            var result = A + B;
-            Console.WriteLine(result.ToString(CultureInfo.InvariantCulture));
-
-            return ExitCode.Success;
-        }
-    }
-}

CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command("console-test")]
+    public class ConsoleTestCommand : ICommand
+    {
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var input = console.Input.ReadToEnd();
+
+            console.WithColors(ConsoleColor.Black, ConsoleColor.White, () =>
+            {
+                console.Output.WriteLine(input);
+                console.Error.WriteLine(input);
+            });
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/DefaultCommand.cs

@@ -1,31 +0,0 @@
-using System;
-using System.Text;
-using CliFx.Attributes;
-using CliFx.Models;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [DefaultCommand]
-    public class DefaultCommand : Command
-    {
-        [CommandOption("target", ShortName = 't', Description = "Greeting target.")]
-        public string Target { get; set; } = "world";
-
-        [CommandOption("enthusiastic", ShortName = 'e', Description = "Whether the greeting should be enthusiastic.")]
-        public bool IsEnthusiastic { get; set; }
-
-        public override ExitCode Execute()
-        {
-            var buffer = new StringBuilder();
-
-            buffer.Append("Hello ").Append(Target);
-
-            if (IsEnthusiastic)
-                buffer.Append("!!!");
-
-            Console.WriteLine(buffer.ToString());
-
-            return ExitCode.Success;
-        }
-    }
-}

CliFx.Tests.Dummy/Commands/HelloWorldCommand.cs

@@ -0,0 +1,19 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command]
+    public class HelloWorldCommand : ICommand
+    {
+        [CommandOption("target", EnvironmentVariableName = "ENV_TARGET")]
+        public string Target { get; set; } = "World";
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine($"Hello {Target}!");
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/LogCommand.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Globalization;
-using CliFx.Attributes;
-using CliFx.Models;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command("log")]
-    public class LogCommand : Command
-    {
-        [CommandOption("value", IsRequired = true, Description = "Value whose logarithm is to be found.")]
-        public double Value { get; set; }
-
-        [CommandOption("base", Description = "Logarithm base.")]
-        public double Base { get; set; } = 10;
-
-        public override ExitCode Execute()
-        {
-            var result = Math.Log(Value, Base);
-            Console.WriteLine(result.ToString(CultureInfo.InvariantCulture));
-
-            return ExitCode.Success;
-        }
-    }
-}

CliFx.Tests.Dummy/Program.cs

@@ -1,9 +1,21 @@
-using System.Threading.Tasks;
+using System.Reflection;
+using System.Threading.Tasks;
 
 namespace CliFx.Tests.Dummy
 {
-    public static class Program
+    public static partial class Program
     {
-        public static Task<int> Main(string[] args) => new CliApplication().RunAsync(args);
+        public static Assembly Assembly { get; } = typeof(Program).Assembly;
+
+        public static string Location { get; } = Assembly.Location;
+    }
+
+    public static partial class Program
+    {
+        public static async Task Main() =>
+            await new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .Build()
+                .RunAsync();
     }
 }

CliFx.Tests/ApplicationSpecs.Commands.cs

@@ -0,0 +1,137 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class ApplicationSpecs
+    {
+        [Command]
+        private class NonImplementedCommand
+        {
+        }
+
+        private class NonAnnotatedCommand : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("dup")]
+        private class DuplicateNameCommandA : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("dup")]
+        private class DuplicateNameCommandB : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class DuplicateParameterOrderCommand : ICommand
+        {
+            [CommandParameter(13)]
+            public string? ParameterA { get; set; }
+
+            [CommandParameter(13)]
+            public string? ParameterB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class DuplicateParameterNameCommand : ICommand
+        {
+            [CommandParameter(0, Name = "param")]
+            public string? ParameterA { get; set; }
+
+            [CommandParameter(1, Name = "param")]
+            public string? ParameterB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class MultipleNonScalarParametersCommand : ICommand
+        {
+            [CommandParameter(0)]
+            public IReadOnlyList<string>? ParameterA { get; set; }
+
+            [CommandParameter(1)]
+            public IReadOnlyList<string>? ParameterB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class NonLastNonScalarParameterCommand : ICommand
+        {
+            [CommandParameter(0)]
+            public IReadOnlyList<string>? ParameterA { get; set; }
+
+            [CommandParameter(1)]
+            public string? ParameterB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class DuplicateOptionNamesCommand : ICommand
+        {
+            [CommandOption("fruits")]
+            public string? Apples { get; set; }
+
+            [CommandOption("fruits")]
+            public string? Oranges { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class DuplicateOptionShortNamesCommand : ICommand
+        {
+            [CommandOption('x')]
+            public string? OptionA { get; set; }
+
+            [CommandOption('x')]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class DuplicateOptionEnvironmentVariableNamesCommand : ICommand
+        {
+            [CommandOption("option-a", EnvironmentVariableName = "ENV_VAR")]
+            public string? OptionA { get; set; }
+
+            [CommandOption("option-b", EnvironmentVariableName = "ENV_VAR")]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class ValidCommand : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("hidden", Description = "Description")]
+        private class HiddenPropertiesCommand : ICommand
+        {
+            [CommandParameter(13, Name = "param", Description = "Param description")]
+            public string? Parameter { get; set; }
+
+            [CommandOption("option", 'o', Description = "Option description", EnvironmentVariableName = "ENV")]
+            public string? Option { get; set; }
+
+            public string? HiddenA { get; set; }
+
+            public bool? HiddenB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/ApplicationSpecs.cs

@@ -0,0 +1,197 @@
+using System;
+using System.IO;
+using CliFx.Domain;
+using CliFx.Exceptions;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class ApplicationSpecs
+    {
+        [Fact]
+        public void Application_can_be_created_with_a_default_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .Build();
+
+            // Assert
+            app.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Application_can_be_created_with_a_custom_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommand(typeof(ValidCommand))
+                .AddCommandsFrom(typeof(ValidCommand).Assembly)
+                .AddCommands(new[] {typeof(ValidCommand)})
+                .AddCommandsFrom(new[] {typeof(ValidCommand).Assembly})
+                .AddCommandsFromThisAssembly()
+                .AllowDebugMode()
+                .AllowPreviewMode()
+                .UseTitle("test")
+                .UseExecutableName("test")
+                .UseVersionText("test")
+                .UseDescription("test")
+                .UseConsole(new VirtualConsole(Stream.Null))
+                .UseTypeActivator(Activator.CreateInstance)
+                .Build();
+
+            // Assert
+            app.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void At_least_one_command_must_be_defined_in_an_application()
+        {
+            // Arrange
+            var commandTypes = Array.Empty<Type>();
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Commands_must_implement_the_corresponding_interface()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(NonImplementedCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Commands_must_be_annotated_by_an_attribute()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(NonAnnotatedCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Commands_must_have_unique_names()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateNameCommandA), typeof(DuplicateNameCommandB)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_parameters_must_have_unique_order()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateParameterOrderCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_parameters_must_have_unique_names()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateParameterNameCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_parameter_can_be_non_scalar_only_if_no_other_such_parameter_is_present()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(MultipleNonScalarParametersCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_parameter_can_be_non_scalar_only_if_it_is_the_last_in_order()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(NonLastNonScalarParameterCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_options_must_have_unique_names()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateOptionNamesCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_options_must_have_unique_short_names()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateOptionShortNamesCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_options_must_have_unique_environment_variable_names()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(DuplicateOptionEnvironmentVariableNamesCommand)};
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() => ApplicationSchema.Resolve(commandTypes));
+        }
+
+        [Fact]
+        public void Command_options_and_parameters_must_be_annotated_by_corresponding_attributes()
+        {
+            // Arrange
+            var commandTypes = new[] {typeof(HiddenPropertiesCommand)};
+
+            // Act
+            var schema = ApplicationSchema.Resolve(commandTypes);
+
+            // Assert
+            schema.Should().BeEquivalentTo(new ApplicationSchema(new[]
+            {
+                new CommandSchema(
+                    typeof(HiddenPropertiesCommand),
+                    "hidden",
+                    "Description",
+                    new[]
+                    {
+                        new CommandParameterSchema(
+                            typeof(HiddenPropertiesCommand).GetProperty(nameof(HiddenPropertiesCommand.Parameter)),
+                            13,
+                            "param",
+                            "Param description")
+                    },
+                    new[]
+                    {
+                        new CommandOptionSchema(
+                            typeof(HiddenPropertiesCommand).GetProperty(nameof(HiddenPropertiesCommand.Option)),
+                            "option",
+                            'o',
+                            "ENV",
+                            false,
+                            "Option description")
+                    })
+            }));
+
+            schema.ToString().Should().NotBeNullOrWhiteSpace(); // this is only for coverage, I'm sorry
+        }
+    }
+}

CliFx.Tests/ArgumentBindingSpecs.Commands.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class ArgumentBindingSpecs
+    {
+        [Command]
+        private class AllSupportedTypesCommand : ICommand
+        {
+            [CommandOption(nameof(Object))]
+            public object? Object { get; set; } = 42;
+
+            [CommandOption(nameof(String))]
+            public string? String { get; set; } = "foo bar";
+
+            [CommandOption(nameof(Bool))]
+            public bool Bool { get; set; }
+
+            [CommandOption(nameof(Char))]
+            public char Char { get; set; }
+
+            [CommandOption(nameof(Sbyte))]
+            public sbyte Sbyte { get; set; }
+
+            [CommandOption(nameof(Byte))]
+            public byte Byte { get; set; }
+
+            [CommandOption(nameof(Short))]
+            public short Short { get; set; }
+
+            [CommandOption(nameof(Ushort))]
+            public ushort Ushort { get; set; }
+
+            [CommandOption(nameof(Int))]
+            public int Int { get; set; }
+
+            [CommandOption(nameof(Uint))]
+            public uint Uint { get; set; }
+
+            [CommandOption(nameof(Long))]
+            public long Long { get; set; }
+
+            [CommandOption(nameof(Ulong))]
+            public ulong Ulong { get; set; }
+
+            [CommandOption(nameof(Float))]
+            public float Float { get; set; }
+
+            [CommandOption(nameof(Double))]
+            public double Double { get; set; }
+
+            [CommandOption(nameof(Decimal))]
+            public decimal Decimal { get; set; }
+
+            [CommandOption(nameof(DateTime))]
+            public DateTime DateTime { get; set; }
+
+            [CommandOption(nameof(DateTimeOffset))]
+            public DateTimeOffset DateTimeOffset { get; set; }
+
+            [CommandOption(nameof(TimeSpan))]
+            public TimeSpan TimeSpan { get; set; }
+
+            [CommandOption(nameof(CustomEnum))]
+            public CustomEnum CustomEnum { get; set; }
+
+            [CommandOption(nameof(IntNullable))]
+            public int? IntNullable { get; set; }
+
+            [CommandOption(nameof(CustomEnumNullable))]
+            public CustomEnum? CustomEnumNullable { get; set; }
+
+            [CommandOption(nameof(TimeSpanNullable))]
+            public TimeSpan? TimeSpanNullable { get; set; }
+
+            [CommandOption(nameof(TestStringConstructable))]
+            public StringConstructable? TestStringConstructable { get; set; }
+
+            [CommandOption(nameof(TestStringParseable))]
+            public StringParseable? TestStringParseable { get; set; }
+
+            [CommandOption(nameof(TestStringParseableWithFormatProvider))]
+            public StringParseableWithFormatProvider? TestStringParseableWithFormatProvider { get; set; }
+
+            [CommandOption(nameof(ObjectArray))]
+            public object[]? ObjectArray { get; set; }
+
+            [CommandOption(nameof(StringArray))]
+            public string[]? StringArray { get; set; }
+
+            [CommandOption(nameof(IntArray))]
+            public int[]? IntArray { get; set; }
+
+            [CommandOption(nameof(CustomEnumArray))]
+            public CustomEnum[]? CustomEnumArray { get; set; }
+
+            [CommandOption(nameof(IntNullableArray))]
+            public int?[]? IntNullableArray { get; set; }
+
+            [CommandOption(nameof(TestStringConstructableArray))]
+            public StringConstructable[]? TestStringConstructableArray { get; set; }
+
+            [CommandOption(nameof(Enumerable))]
+            public IEnumerable? Enumerable { get; set; }
+
+            [CommandOption(nameof(StringEnumerable))]
+            public IEnumerable<string>? StringEnumerable { get; set; }
+
+            [CommandOption(nameof(StringReadOnlyList))]
+            public IReadOnlyList<string>? StringReadOnlyList { get; set; }
+
+            [CommandOption(nameof(StringList))]
+            public List<string>? StringList { get; set; }
+
+            [CommandOption(nameof(StringHashSet))]
+            public HashSet<string>? StringHashSet { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class ArrayOptionCommand : ICommand
+        {
+            [CommandOption("option", 'o')]
+            public IReadOnlyList<string>? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class RequiredOptionCommand : ICommand
+        {
+            [CommandOption(nameof(OptionA))]
+            public string? OptionA { get; set; }
+
+            [CommandOption(nameof(OptionB), IsRequired = true)]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class ParametersCommand : ICommand
+        {
+            [CommandParameter(0)]
+            public string? ParameterA { get; set; }
+
+            [CommandParameter(1)]
+            public string? ParameterB { get; set; }
+
+            [CommandParameter(2)]
+            public IReadOnlyList<string>? ParameterC { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class UnsupportedPropertyTypeCommand : ICommand
+        {
+            [CommandOption(nameof(Option))]
+            public DummyType? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class UnsupportedEnumerablePropertyTypeCommand : ICommand
+        {
+            [CommandOption(nameof(Option))]
+            public CustomEnumerable<string>? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class NoParameterCommand : ICommand
+        {
+            [CommandOption(nameof(OptionA))]
+            public string? OptionA { get; set; }
+
+            [CommandOption(nameof(OptionB))]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/ArgumentBindingSpecs.Types.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace CliFx.Tests
+{
+    public partial class ArgumentBindingSpecs
+    {
+        private enum CustomEnum
+        {
+            Value1 = 1,
+            Value2 = 2,
+            Value3 = 3
+        }
+
+        private class StringConstructable
+        {
+            public string Value { get; }
+
+            public StringConstructable(string value)
+            {
+                Value = value;
+            }
+        }
+
+        private class StringParseable
+        {
+            public string Value { get; }
+
+            private StringParseable(string value)
+            {
+                Value = value;
+            }
+
+            public static StringParseable Parse(string value) => new StringParseable(value);
+        }
+
+        private class StringParseableWithFormatProvider
+        {
+            public string Value { get; }
+
+            private StringParseableWithFormatProvider(string value)
+            {
+                Value = value;
+            }
+
+            public static StringParseableWithFormatProvider Parse(string value, IFormatProvider formatProvider) =>
+                new StringParseableWithFormatProvider(value + " " + formatProvider);
+        }
+
+        private class DummyType
+        {
+        }
+
+        public class CustomEnumerable<T> : IEnumerable<T>
+        {
+            private readonly T[] _arr = new T[0];
+
+            public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>) _arr).GetEnumerator();
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+    }
+}

CliFx.Tests/ArgumentSyntaxSpecs.cs

@@ -0,0 +1,315 @@
+using System;
+using CliFx.Domain;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class ArgumentSyntaxSpecs
+    {
+        [Fact]
+        public void Input_is_empty_if_no_arguments_are_provided()
+        {
+            // Arrange
+            var args = Array.Empty<string>();
+
+            // Act
+            var input = CommandLineInput.Parse(args);
+
+            // Assert
+            input.Should().BeEquivalentTo(CommandLineInput.Empty);
+        }
+
+        public static object[][] DirectivesTestData => new[]
+        {
+            new object[]
+            {
+                new[] {"[preview]"},
+                new CommandLineInputBuilder()
+                    .AddDirective("preview")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"[preview]", "[debug]"},
+                new CommandLineInputBuilder()
+                    .AddDirective("preview")
+                    .AddDirective("debug")
+                    .Build()
+            }
+        };
+
+        [Theory]
+        [MemberData(nameof(DirectivesTestData))]
+        internal void Directive_can_be_enabled_by_specifying_its_name_in_square_brackets(string[] arguments, CommandLineInput expectedInput)
+        {
+            // Act
+            var input = CommandLineInput.Parse(arguments);
+
+            // Assert
+            input.Should().BeEquivalentTo(expectedInput);
+        }
+
+        public static object[][] OptionsTestData => new[]
+        {
+            new object[]
+            {
+                new[] {"--option"},
+                new CommandLineInputBuilder()
+                    .AddOption("option")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option", "value"},
+                new CommandLineInputBuilder()
+                    .AddOption("option", "value")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option", "value1", "value2"},
+                new CommandLineInputBuilder()
+                    .AddOption("option", "value1", "value2")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option", "same value"},
+                new CommandLineInputBuilder()
+                    .AddOption("option", "same value")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option1", "--option2"},
+                new CommandLineInputBuilder()
+                    .AddOption("option1")
+                    .AddOption("option2")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option1", "value1", "--option2", "value2"},
+                new CommandLineInputBuilder()
+                    .AddOption("option1", "value1")
+                    .AddOption("option2", "value2")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option1", "value1", "value2", "--option2", "value3", "value4"},
+                new CommandLineInputBuilder()
+                    .AddOption("option1", "value1", "value2")
+                    .AddOption("option2", "value3", "value4")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"--option1", "value1", "value2", "--option2"},
+                new CommandLineInputBuilder()
+                    .AddOption("option1", "value1", "value2")
+                    .AddOption("option2")
+                    .Build()
+            }
+        };
+
+        [Theory]
+        [MemberData(nameof(OptionsTestData))]
+        internal void Option_can_be_set_by_specifying_its_name_after_two_dashes(string[] arguments, CommandLineInput expectedInput)
+        {
+            // Act
+            var input = CommandLineInput.Parse(arguments);
+
+            // Assert
+            input.Should().BeEquivalentTo(expectedInput);
+        }
+
+        public static object[][] ShortOptionsTestData => new[]
+        {
+            new object[]
+            {
+                new[] {"-o"},
+                new CommandLineInputBuilder()
+                    .AddOption("o")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-o", "value"},
+                new CommandLineInputBuilder()
+                    .AddOption("o", "value")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-o", "value1", "value2"},
+                new CommandLineInputBuilder()
+                    .AddOption("o", "value1", "value2")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-o", "same value"},
+                new CommandLineInputBuilder()
+                    .AddOption("o", "same value")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-a", "-b"},
+                new CommandLineInputBuilder()
+                    .AddOption("a")
+                    .AddOption("b")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-a", "value1", "-b", "value2"},
+                new CommandLineInputBuilder()
+                    .AddOption("a", "value1")
+                    .AddOption("b", "value2")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-a", "value1", "value2", "-b", "value3", "value4"},
+                new CommandLineInputBuilder()
+                    .AddOption("a", "value1", "value2")
+                    .AddOption("b", "value3", "value4")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-a", "value1", "value2", "-b"},
+                new CommandLineInputBuilder()
+                    .AddOption("a", "value1", "value2")
+                    .AddOption("b")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-abc"},
+                new CommandLineInputBuilder()
+                    .AddOption("a")
+                    .AddOption("b")
+                    .AddOption("c")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-abc", "value"},
+                new CommandLineInputBuilder()
+                    .AddOption("a")
+                    .AddOption("b")
+                    .AddOption("c", "value")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"-abc", "value1", "value2"},
+                new CommandLineInputBuilder()
+                    .AddOption("a")
+                    .AddOption("b")
+                    .AddOption("c", "value1", "value2")
+                    .Build()
+            }
+        };
+
+        [Theory]
+        [MemberData(nameof(ShortOptionsTestData))]
+        internal void Option_can_be_set_by_specifying_its_short_name_after_a_single_dash(string[] arguments, CommandLineInput expectedInput)
+        {
+            // Act
+            var input = CommandLineInput.Parse(arguments);
+
+            // Assert
+            input.Should().BeEquivalentTo(expectedInput);
+        }
+
+        public static object[][] UnboundArgumentsTestData => new[]
+        {
+            new object[]
+            {
+                new[] {"foo"},
+                new CommandLineInputBuilder()
+                    .AddUnboundArgument("foo")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"foo", "bar"},
+                new CommandLineInputBuilder()
+                    .AddUnboundArgument("foo")
+                    .AddUnboundArgument("bar")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"[preview]", "foo"},
+                new CommandLineInputBuilder()
+                    .AddDirective("preview")
+                    .AddUnboundArgument("foo")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"foo", "--option", "value", "-abc"},
+                new CommandLineInputBuilder()
+                    .AddUnboundArgument("foo")
+                    .AddOption("option", "value")
+                    .AddOption("a")
+                    .AddOption("b")
+                    .AddOption("c")
+                    .Build()
+            },
+
+            new object[]
+            {
+                new[] {"[preview]", "[debug]", "foo", "bar", "--option", "value", "-abc"},
+                new CommandLineInputBuilder()
+                    .AddDirective("preview")
+                    .AddDirective("debug")
+                    .AddUnboundArgument("foo")
+                    .AddUnboundArgument("bar")
+                    .AddOption("option", "value")
+                    .AddOption("a")
+                    .AddOption("b")
+                    .AddOption("c")
+                    .Build()
+            }
+        };
+
+        [Theory]
+        [MemberData(nameof(UnboundArgumentsTestData))]
+        internal void Any_remaining_arguments_are_treated_as_unbound_arguments(string[] arguments, CommandLineInput expectedInput)
+        {
+            // Act
+            var input = CommandLineInput.Parse(arguments);
+
+            // Assert
+            input.Should().BeEquivalentTo(expectedInput);
+        }
+    }
+}

CliFx.Tests/CancellationSpecs.Commands.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class CancellationSpecs
+    {
+        [Command("cancel")]
+        private class CancellableCommand : ICommand
+        {
+            public async ValueTask ExecuteAsync(IConsole console)
+            {
+                try
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(3), console.GetCancellationToken());
+                    console.Output.WriteLine("Never printed");
+                }
+                catch (OperationCanceledException)
+                {
+                    console.Output.WriteLine("Cancellation requested");
+                    throw;
+                }
+            }
+        }
+    }
+}

CliFx.Tests/CancellationSpecs.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class CancellationSpecs
+    {
+        [Fact]
+        public async Task Command_can_perform_additional_cleanup_if_cancellation_is_requested()
+        {
+            // Arrange
+            using var cts = new CancellationTokenSource();
+
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut, cancellationToken: cts.Token);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(CancellableCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            cts.CancelAfter(TimeSpan.FromSeconds(0.2));
+
+            var exitCode = await application.RunAsync(
+                new[] {"cancel"},
+                new Dictionary<string, string>());
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdOutData.Should().Be("Cancellation requested");
+        }
+    }
+}

CliFx.Tests/CliApplicationTests.cs

@@ -1,33 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using CliFx.Services;
-using CliFx.Tests.TestObjects;
-using Moq;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CliApplicationTests
-    {
-        [Test]
-        public async Task RunAsync_Test()
-        {
-            // Arrange
-            var command = new TestCommand();
-            var expectedExitCode = await command.ExecuteAsync();
-
-            var commandResolverMock = new Mock<ICommandResolver>();
-            commandResolverMock.Setup(m => m.ResolveCommand(It.IsAny<IReadOnlyList<string>>())).Returns(command);
-            var commandResolver = commandResolverMock.Object;
-
-            var application = new CliApplication(commandResolver);
-
-            // Act
-            var exitCodeValue = await application.RunAsync();
-
-            // Assert
-            Assert.That(exitCodeValue, Is.EqualTo(expectedExitCode.Value));
-        }
-    }
-}

CliFx.Tests/CliFx.Tests.csproj

@@ -1,18 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
-    <TargetFramework>net45</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
-    <LangVersion>latest</LangVersion>
+    <CollectCoverage>true</CollectCoverage>
+    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
-    <PackageReference Include="NUnit" Version="3.11.0" />
+  </ItemGroup>
-    <PackageReference Include="NUnit3TestAdapter" Version="3.11.0" />
+
-    <PackageReference Include="Moq" Version="4.11.0" />
+  <ItemGroup>
-    <PackageReference Include="CliWrap" Version="2.3.0" />
+    <PackageReference Include="CliWrap" Version="3.0.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -20,4 +28,12 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
+      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>False</Visible>
+    </None>
+  </ItemGroup>
+
 </Project>

CliFx.Tests/CommandOptionConverterTests.cs

@@ -1,83 +0,0 @@
-using System;
-using System.Collections.Generic;
-using CliFx.Services;
-using CliFx.Tests.TestObjects;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CommandOptionConverterTests
-    {
-        private static IEnumerable<TestCaseData> GetData_ConvertOption()
-        {
-            yield return new TestCaseData("value", typeof(string), "value")
-                .SetName("To string");
-
-            yield return new TestCaseData("value", typeof(object), "value")
-                .SetName("To object");
-
-            yield return new TestCaseData("true", typeof(bool), true)
-                .SetName("To bool (true)");
-
-            yield return new TestCaseData("false", typeof(bool), false)
-                .SetName("To bool (false)");
-
-            yield return new TestCaseData(null, typeof(bool), true)
-                .SetName("To bool (switch)");
-
-            yield return new TestCaseData("123", typeof(int), 123)
-                .SetName("To int");
-
-            yield return new TestCaseData("123.45", typeof(double), 123.45)
-                .SetName("To double");
-
-            yield return new TestCaseData("28 Apr 1995", typeof(DateTime), new DateTime(1995, 04, 28))
-                .SetName("To DateTime");
-
-            yield return new TestCaseData("28 Apr 1995", typeof(DateTimeOffset), new DateTimeOffset(new DateTime(1995, 04, 28)))
-                .SetName("To DateTimeOffset");
-
-            yield return new TestCaseData("00:14:59", typeof(TimeSpan), new TimeSpan(00, 14, 59))
-                .SetName("To TimeSpan");
-
-            yield return new TestCaseData("value2", typeof(TestEnum), TestEnum.Value2)
-                .SetName("To enum");
-
-            yield return new TestCaseData("666", typeof(int?), 666)
-                .SetName("To int? (with value)");
-
-            yield return new TestCaseData(null, typeof(int?), null)
-                .SetName("To int? (no value)");
-
-            yield return new TestCaseData("value3", typeof(TestEnum?), TestEnum.Value3)
-                .SetName("To enum? (with value)");
-
-            yield return new TestCaseData(null, typeof(TestEnum?), null)
-                .SetName("To enum? (no value)");
-
-            yield return new TestCaseData("01:00:00", typeof(TimeSpan?), new TimeSpan(01, 00, 00))
-                .SetName("To TimeSpan? (with value)");
-
-            yield return new TestCaseData(null, typeof(TimeSpan?), null)
-                .SetName("To TimeSpan? (no value)");
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetData_ConvertOption))]
-        public void ConvertOption_Test(string value, Type targetType, object expectedConvertedValue)
-        {
-            // Arrange
-            var converter = new CommandOptionConverter();
-
-            // Act
-            var convertedValue = converter.ConvertOption(value, targetType);
-
-            // Assert
-            Assert.That(convertedValue, Is.EqualTo(expectedConvertedValue));
-
-            if (convertedValue != null)
-                Assert.That(convertedValue, Is.AssignableTo(targetType));
-        }
-    }
-}

CliFx.Tests/CommandOptionParserTests.cs

@@ -1,139 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Models;
-using CliFx.Services;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CommandOptionParserTests
-    {
-        private static IEnumerable<TestCaseData> GetData_ParseOptions()
-        {
-            yield return new TestCaseData(
-                new string[0],
-                CommandOptionSet.Empty
-            ).SetName("No arguments");
-
-            yield return new TestCaseData(
-                new[] {"--argument", "value"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"argument", "value"}
-                })
-            ).SetName("Single argument");
-
-            yield return new TestCaseData(
-                new[] {"--argument1", "value1", "--argument2", "value2", "--argument3", "value3"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"argument1", "value1"},
-                    {"argument2", "value2"},
-                    {"argument3", "value3"}
-                })
-            ).SetName("Multiple arguments");
-
-            yield return new TestCaseData(
-                new[] {"-a", "value"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"a", "value"}
-                })
-            ).SetName("Single short argument");
-
-            yield return new TestCaseData(
-                new[] {"-a", "value1", "-b", "value2", "-c", "value3"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"a", "value1"},
-                    {"b", "value2"},
-                    {"c", "value3"}
-                })
-            ).SetName("Multiple short arguments");
-
-            yield return new TestCaseData(
-                new[] {"--argument1", "value1", "-b", "value2", "--argument3", "value3"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"argument1", "value1"},
-                    {"b", "value2"},
-                    {"argument3", "value3"}
-                })
-            ).SetName("Multiple mixed arguments");
-
-            yield return new TestCaseData(
-                new[] {"--switch"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"switch", null}
-                })
-            ).SetName("Single switch");
-
-            yield return new TestCaseData(
-                new[] {"--switch1", "--switch2", "--switch3"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"switch1", null},
-                    {"switch2", null},
-                    {"switch3", null}
-                })
-            ).SetName("Multiple switches");
-
-            yield return new TestCaseData(
-                new[] {"-s"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"s", null}
-                })
-            ).SetName("Single short switch");
-
-            yield return new TestCaseData(
-                new[] {"-a", "-b", "-c"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"a", null},
-                    {"b", null},
-                    {"c", null}
-                })
-            ).SetName("Multiple short switches");
-
-            yield return new TestCaseData(
-                new[] {"-abc"},
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"a", null},
-                    {"b", null},
-                    {"c", null}
-                })
-            ).SetName("Multiple stacked short switches");
-
-            yield return new TestCaseData(
-                new[] {"command"},
-                new CommandOptionSet("command")
-            ).SetName("No arguments (with command name)");
-
-            yield return new TestCaseData(
-                new[] {"command", "--argument", "value"},
-                new CommandOptionSet("command", new Dictionary<string, string>
-                {
-                    {"argument", "value"}
-                })
-            ).SetName("Single argument (with command name)");
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetData_ParseOptions))]
-        public void ParseOptions_Test(IReadOnlyList<string> commandLineArguments, CommandOptionSet expectedCommandOptionSet)
-        {
-            // Arrange
-            var parser = new CommandOptionParser();
-
-            // Act
-            var optionSet = parser.ParseOptions(commandLineArguments);
-
-            // Assert
-            Assert.That(optionSet.CommandName, Is.EqualTo(expectedCommandOptionSet.CommandName));
-            Assert.That(optionSet.Options, Is.EqualTo(expectedCommandOptionSet.Options));
-        }
-    }
-}

CliFx.Tests/CommandResolverTests.cs

@@ -1,116 +0,0 @@
-using System;
-using System.Collections.Generic;
-using CliFx.Exceptions;
-using CliFx.Models;
-using CliFx.Services;
-using CliFx.Tests.TestObjects;
-using Moq;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CommandResolverTests
-    {
-        private static IEnumerable<TestCaseData> GetData_ResolveCommand()
-        {
-            yield return new TestCaseData(
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"int", "13"}
-                }),
-                new TestCommand {IntOption = 13}
-            ).SetName("Single option");
-
-            yield return new TestCaseData(
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"int", "13"},
-                    {"str", "hello world" }
-                }),
-                new TestCommand { IntOption = 13, StringOption = "hello world"}
-            ).SetName("Multiple options");
-
-            yield return new TestCaseData(
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"i", "13"}
-                }),
-                new TestCommand { IntOption = 13 }
-            ).SetName("Single short option");
-
-            yield return new TestCaseData(
-                new CommandOptionSet("command", new Dictionary<string, string>
-                {
-                    {"int", "13"}
-                }),
-                new TestCommand { IntOption = 13 }
-            ).SetName("Single option (with command name)");
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetData_ResolveCommand))]
-        public void ResolveCommand_Test(CommandOptionSet commandOptionSet, TestCommand expectedCommand)
-        {
-            // Arrange
-            var commandTypes = new[] {typeof(TestCommand)};
-
-            var typeProviderMock = new Mock<ITypeProvider>();
-            typeProviderMock.Setup(m => m.GetTypes()).Returns(commandTypes);
-            var typeProvider = typeProviderMock.Object;
-
-            var optionParserMock = new Mock<ICommandOptionParser>();
-            optionParserMock.Setup(m => m.ParseOptions(It.IsAny<IReadOnlyList<string>>())).Returns(commandOptionSet);
-            var optionParser = optionParserMock.Object;
-
-            var optionConverter = new CommandOptionConverter();
-
-            var resolver = new CommandResolver(typeProvider, optionParser, optionConverter);
-
-            // Act
-            var command = resolver.ResolveCommand() as TestCommand;
-
-            // Assert
-            Assert.That(command, Is.Not.Null);
-            Assert.That(command.StringOption, Is.EqualTo(expectedCommand.StringOption), nameof(command.StringOption));
-            Assert.That(command.IntOption, Is.EqualTo(expectedCommand.IntOption), nameof(command.IntOption));
-        }
-
-        private static IEnumerable<TestCaseData> GetData_ResolveCommand_IsRequired()
-        {
-            yield return new TestCaseData(
-                CommandOptionSet.Empty
-            ).SetName("No options");
-
-            yield return new TestCaseData(
-                new CommandOptionSet(new Dictionary<string, string>
-                {
-                    {"str", "hello world"}
-                })
-            ).SetName("Required option is not set");
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetData_ResolveCommand_IsRequired))]
-        public void ResolveCommand_IsRequired_Test(CommandOptionSet commandOptionSet)
-        {
-            // Arrange
-            var commandTypes = new[] { typeof(TestCommand) };
-
-            var typeProviderMock = new Mock<ITypeProvider>();
-            typeProviderMock.Setup(m => m.GetTypes()).Returns(commandTypes);
-            var typeProvider = typeProviderMock.Object;
-
-            var optionParserMock = new Mock<ICommandOptionParser>();
-            optionParserMock.Setup(m => m.ParseOptions(It.IsAny<IReadOnlyList<string>>())).Returns(commandOptionSet);
-            var optionParser = optionParserMock.Object;
-
-            var optionConverter = new CommandOptionConverter();
-
-            var resolver = new CommandResolver(typeProvider, optionParser, optionConverter);
-
-            // Act & Assert
-            Assert.Throws<CommandResolveException>(() => resolver.ResolveCommand());
-        }
-    }
-}

CliFx.Tests/ConsoleSpecs.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using CliWrap;
+using CliWrap.Buffered;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class ConsoleSpecs
+    {
+        [Fact]
+        public async Task Real_implementation_of_console_maps_directly_to_system_console()
+        {
+            // Arrange
+            var command = "Hello world" | Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location)
+                    .Add("console-test"));
+
+            // Act
+            var result = await command.ExecuteBufferedAsync();
+
+            // Assert
+            result.StandardOutput.TrimEnd().Should().Be("Hello world");
+            result.StandardError.TrimEnd().Should().Be("Hello world");
+        }
+
+        [Fact]
+        public void Fake_implementation_of_console_can_be_used_to_execute_commands_in_isolation()
+        {
+            // Arrange
+            using var stdIn = new MemoryStream(Console.InputEncoding.GetBytes("input"));
+            using var stdOut = new MemoryStream();
+            using var stdErr = new MemoryStream();
+
+            var console = new VirtualConsole(
+                input: stdIn,
+                output: stdOut,
+                error: stdErr);
+
+            // Act
+            console.Output.Write("output");
+            console.Error.Write("error");
+
+            var stdInData = console.Input.ReadToEnd();
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray());
+            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray());
+
+            console.ResetColor();
+            console.ForegroundColor = ConsoleColor.DarkMagenta;
+            console.BackgroundColor = ConsoleColor.DarkMagenta;
+
+            // Assert
+            stdInData.Should().Be("input");
+            stdOutData.Should().Be("output");
+            stdErrData.Should().Be("error");
+
+            console.Input.Should().NotBeSameAs(Console.In);
+            console.Output.Should().NotBeSameAs(Console.Out);
+            console.Error.Should().NotBeSameAs(Console.Error);
+
+            console.IsInputRedirected.Should().BeTrue();
+            console.IsOutputRedirected.Should().BeTrue();
+            console.IsErrorRedirected.Should().BeTrue();
+
+            console.ForegroundColor.Should().NotBe(Console.ForegroundColor);
+            console.BackgroundColor.Should().NotBe(Console.BackgroundColor);
+        }
+    }
+}

CliFx.Tests/DependencyInjectionSpecs.Commands.cs

@@ -0,0 +1,37 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class DependencyInjectionSpecs
+    {
+        [Command]
+        private class WithoutDependenciesCommand : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        private class DependencyA
+        {
+        }
+
+        private class DependencyB
+        {
+        }
+
+        [Command]
+        private class WithDependenciesCommand : ICommand
+        {
+            private readonly DependencyA _dependencyA;
+            private readonly DependencyB _dependencyB;
+
+            public WithDependenciesCommand(DependencyA dependencyA, DependencyB dependencyB)
+            {
+                _dependencyA = dependencyA;
+                _dependencyB = dependencyB;
+            }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/DependencyInjectionSpecs.cs

@@ -0,0 +1,58 @@
+using CliFx.Exceptions;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class DependencyInjectionSpecs
+    {
+        [Fact]
+        public void Default_type_activator_can_initialize_a_command_if_it_has_a_parameterless_constructor()
+        {
+            // Arrange
+            var activator = new DefaultTypeActivator();
+
+            // Act
+            var obj = activator.CreateInstance(typeof(WithoutDependenciesCommand));
+
+            // Assert
+            obj.Should().BeOfType<WithoutDependenciesCommand>();
+        }
+
+        [Fact]
+        public void Default_type_activator_cannot_initialize_a_command_if_it_does_not_have_a_parameterless_constructor()
+        {
+            // Arrange
+            var activator = new DefaultTypeActivator();
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() =>
+                activator.CreateInstance(typeof(WithDependenciesCommand)));
+        }
+
+        [Fact]
+        public void Delegate_type_activator_can_initialize_a_command_using_a_custom_function()
+        {
+            // Arrange
+            var activator = new DelegateTypeActivator(_ =>
+                new WithDependenciesCommand(new DependencyA(), new DependencyB()));
+
+            // Act
+            var obj = activator.CreateInstance(typeof(WithDependenciesCommand));
+
+            // Assert
+            obj.Should().BeOfType<WithDependenciesCommand>();
+        }
+
+        [Fact]
+        public void Delegate_type_activator_throws_if_the_underlying_function_returns_null()
+        {
+            // Arrange
+            var activator = new DelegateTypeActivator(_ => null);
+
+            // Act & assert
+            Assert.Throws<CliFxException>(() =>
+                activator.CreateInstance(typeof(WithDependenciesCommand)));
+        }
+    }
+}

CliFx.Tests/DirectivesSpecs.Commands.cs

@@ -0,0 +1,14 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class DirectivesSpecs
+    {
+        [Command("cmd")]
+        private class NamedCommand : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/DirectivesSpecs.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class DirectivesSpecs
+    {
+        [Fact]
+        public async Task Preview_directive_can_be_enabled_to_print_provided_arguments_as_they_were_parsed()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(NamedCommand))
+                .UseConsole(console)
+                .AllowPreviewMode()
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"[preview]", "cmd", "param", "-abc", "--option", "foo"},
+                new Dictionary<string, string>());
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOutData.Should().ContainAll("cmd", "<param>", "[-a]", "[-b]", "[-c]", "[--option foo]");
+        }
+    }
+}

CliFx.Tests/DummyTests.cs

@@ -1,32 +0,0 @@
-using System.IO;
-using System.Threading.Tasks;
-using CliWrap;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class DummyTests
-    {
-        private string DummyFilePath => Path.Combine(TestContext.CurrentContext.TestDirectory, "CliFx.Tests.Dummy.exe");
-
-        [Test]
-        [TestCase("", "Hello world")]
-        [TestCase("-t .NET", "Hello .NET")]
-        [TestCase("-e", "Hello world!!!")]
-        [TestCase("add --a 1 --b 2", "3")]
-        [TestCase("add --a 2.75 --b 3.6", "6.35")]
-        [TestCase("log --value 100", "2")]
-        [TestCase("log --value 256 --base 2", "8")]
-        public async Task Execute_Test(string arguments, string expectedOutput)
-        {
-            // Act
-            var result = await Cli.Wrap(DummyFilePath).SetArguments(arguments).ExecuteAsync();
-
-            // Assert
-            Assert.That(result.ExitCode, Is.Zero);
-            Assert.That(result.StandardOutput.Trim(), Is.EqualTo(expectedOutput));
-            Assert.That(result.StandardError.Trim(), Is.Empty);
-        }
-    }
-}

CliFx.Tests/EnvironmentVariablesSpecs.Commands.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class EnvironmentVariablesSpecs
+    {
+        [Command]
+        private class EnvironmentVariableCollectionCommand : ICommand
+        {
+            [CommandOption("opt", EnvironmentVariableName = "ENV_OPT")]
+            public IReadOnlyList<string>? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command]
+        private class EnvironmentVariableCommand : ICommand
+        {
+            [CommandOption("opt", EnvironmentVariableName = "ENV_OPT")]
+            public string? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/EnvironmentVariablesSpecs.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using CliFx.Domain;
+using CliWrap;
+using CliWrap.Buffered;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class EnvironmentVariablesSpecs
+    {
+        // This test uses a real application to make sure environment variables are actually read correctly
+        [Fact]
+        public async Task Option_can_use_a_specific_environment_variable_as_fallback()
+        {
+            // Arrange
+            var command = Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location))
+                .WithEnvironmentVariables(e => e
+                    .Set("ENV_TARGET", "Mars"));
+
+            // Act
+            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);
+
+            // Assert
+            stdOut.TrimEnd().Should().Be("Hello Mars!");
+        }
+
+        // This test uses a real application to make sure environment variables are actually read correctly
+        [Fact]
+        public async Task Option_only_uses_environment_variable_as_fallback_if_the_value_was_not_directly_provided()
+        {
+            // Arrange
+            var command = Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location)
+                    .Add("--target")
+                    .Add("Jupiter"))
+                .WithEnvironmentVariables(e => e
+                    .Set("ENV_TARGET", "Mars"));
+
+            // Act
+            var stdOut = await command.ExecuteBufferedAsync().Select(r => r.StandardOutput);
+
+            // Assert
+            stdOut.TrimEnd().Should().Be("Hello Jupiter!");
+        }
+
+        [Fact]
+        public void Option_of_non_scalar_type_can_take_multiple_separated_values_from_an_environment_variable()
+        {
+            // Arrange
+            var schema = ApplicationSchema.Resolve(new[] {typeof(EnvironmentVariableCollectionCommand)});
+
+            var input = CommandLineInput.Empty;
+            var envVars = new Dictionary<string, string>
+            {
+                ["ENV_OPT"] = $"foo{Path.PathSeparator}bar"
+            };
+
+            // Act
+            var command = schema.InitializeEntryPoint(input, envVars);
+
+            // Assert
+            command.Should().BeEquivalentTo(new EnvironmentVariableCollectionCommand
+            {
+                Option = new[] {"foo", "bar"}
+            });
+        }
+
+        [Fact]
+        public void Option_of_scalar_type_can_only_take_a_single_value_from_an_environment_variable_even_if_it_contains_separators()
+        {
+            // Arrange
+            var schema = ApplicationSchema.Resolve(new[] {typeof(EnvironmentVariableCommand)});
+
+            var input = CommandLineInput.Empty;
+            var envVars = new Dictionary<string, string>
+            {
+                ["ENV_OPT"] = $"foo{Path.PathSeparator}bar"
+            };
+
+            // Act
+            var command = schema.InitializeEntryPoint(input, envVars);
+
+            // Assert
+            command.Should().BeEquivalentTo(new EnvironmentVariableCommand
+            {
+                Option = $"foo{Path.PathSeparator}bar"
+            });
+        }
+    }
+}

CliFx.Tests/ErrorReportingSpecs.Commands.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Exceptions;
+
+namespace CliFx.Tests
+{
+    public partial class ErrorReportingSpecs
+    {
+        [Command("exc")]
+        private class GenericExceptionCommand : ICommand
+        {
+            [CommandOption("msg", 'm')]
+            public string? Message { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => throw new Exception(Message);
+        }
+
+        [Command("exc")]
+        private class CommandExceptionCommand : ICommand
+        {
+            [CommandOption("code", 'c')]
+            public int ExitCode { get; set; } = 1337;
+
+            [CommandOption("msg", 'm')]
+            public string? Message { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => throw new CommandException(Message, ExitCode);
+        }
+    }
+}

CliFx.Tests/ErrorReportingSpecs.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class ErrorReportingSpecs
+    {
+        [Fact]
+        public async Task Command_may_throw_a_generic_exception_which_exits_and_prints_full_error_details()
+        {
+            // Arrange
+            await using var stdErr = new MemoryStream();
+            var console = new VirtualConsole(error: stdErr);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(GenericExceptionCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"exc", "-m", "Kaput"},
+                new Dictionary<string, string>());
+
+            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErrData.Should().Contain("Kaput");
+            stdErrData.Length.Should().BeGreaterThan("Kaput".Length);
+        }
+
+        [Fact]
+        public async Task Command_may_throw_a_specialized_exception_which_exits_with_custom_code_and_prints_minimal_error_details()
+        {
+            // Arrange
+            await using var stdErr = new MemoryStream();
+            var console = new VirtualConsole(error: stdErr);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(CommandExceptionCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"exc", "-m", "Kaput", "-c", "69"},
+                new Dictionary<string, string>());
+
+            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(69);
+            stdErrData.Should().Be("Kaput");
+        }
+
+        [Fact]
+        public async Task Command_may_throw_a_specialized_exception_without_error_message_which_exits_and_prints_full_error_details()
+        {
+            // Arrange
+            await using var stdErr = new MemoryStream();
+            var console = new VirtualConsole(error: stdErr);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(CommandExceptionCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"exc", "-m", "Kaput"},
+                new Dictionary<string, string>());
+
+            var stdErrData = console.Error.Encoding.GetString(stdErr.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErrData.Should().NotBeEmpty();
+        }
+    }
+}

CliFx.Tests/HelpTextSpecs.Commands.cs

@@ -0,0 +1,96 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class HelpTextSpecs
+    {
+        [Command(Description = "DefaultCommand description.")]
+        private class DefaultCommand : ICommand
+        {
+            [CommandOption("option-a", 'a', Description = "OptionA description.")]
+            public string? OptionA { get; set; }
+
+            [CommandOption("option-b", 'b', Description = "OptionB description.")]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("cmd", Description = "NamedCommand description.")]
+        private class NamedCommand : ICommand
+        {
+            [CommandParameter(0, Name = "param-a", Description = "ParameterA description.")]
+            public string? ParameterA { get; set; }
+
+            [CommandOption("option-c", 'c', Description = "OptionC description.")]
+            public string? OptionC { get; set; }
+
+            [CommandOption("option-d", 'd', Description = "OptionD description.")]
+            public string? OptionD { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("cmd sub", Description = "NamedSubCommand description.")]
+        private class NamedSubCommand : ICommand
+        {
+            [CommandParameter(0, Name = "param-b", Description = "ParameterB description.")]
+            public string? ParameterB { get; set; }
+
+            [CommandParameter(1, Name = "param-c", Description = "ParameterC description.")]
+            public string? ParameterC { get; set; }
+
+            [CommandOption("option-e", 'e', Description = "OptionE description.")]
+            public string? OptionE { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("cmd-with-params")]
+        private class ParametersCommand : ICommand
+        {
+            [CommandParameter(0, Name = "first")]
+            public string? ParameterA { get; set; }
+
+            [CommandParameter(10)]
+            public int? ParameterB { get; set; }
+
+            [CommandParameter(20, Description = "A list of numbers", Name = "third list")]
+            public IEnumerable<int>? ParameterC { get; set; }
+
+            [CommandOption("option", 'o')]
+            public string? Option { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("cmd-with-req-opts")]
+        private class RequiredOptionsCommand : ICommand
+        {
+            [CommandOption("option-f", 'f', IsRequired = true)]
+            public string? OptionF { get; set; }
+
+            [CommandOption("option-g", 'g', IsRequired = true)]
+            public IEnumerable<int>? OptionG { get; set; }
+
+            [CommandOption("option-h", 'h')]
+            public string? OptionH { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Command("cmd-with-env-vars")]
+        private class EnvironmentVariableCommand : ICommand
+        {
+            [CommandOption("option-a", 'a', IsRequired = true, EnvironmentVariableName = "ENV_OPT_A")]
+            public string? OptionA { get; set; }
+
+            [CommandOption("option-b", 'b', EnvironmentVariableName = "ENV_OPT_B")]
+            public string? OptionB { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+    }
+}

CliFx.Tests/HelpTextSpecs.cs

@@ -0,0 +1,246 @@
+using System.IO;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class HelpTextSpecs
+    {
+        [Fact]
+        public async Task Version_information_can_be_requested_by_providing_the_version_option_without_other_arguments()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(NamedCommand))
+                .AddCommand(typeof(NamedSubCommand))
+                .UseVersionText("v6.9")
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(new[] {"--version"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOutData.Should().Be("v6.9");
+        }
+
+        [Fact]
+        public async Task Help_text_can_be_requested_by_providing_the_help_option()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(NamedCommand))
+                .AddCommand(typeof(NamedSubCommand))
+                .UseTitle("AppTitle")
+                .UseVersionText("AppVer")
+                .UseDescription("AppDesc")
+                .UseExecutableName("AppExe")
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "AppTitle", "AppVer",
+                "AppDesc",
+                "Usage",
+                "AppExe", "[command]", "[options]",
+                "Options",
+                "-a|--option-a", "OptionA description.",
+                "-b|--option-b", "OptionB description.",
+                "-h|--help", "Shows help text.",
+                "--version", "Shows version information.",
+                "Commands",
+                "cmd", "NamedCommand description.",
+                "You can run", "to show help on a specific command."
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_can_be_requested_on_a_specific_named_command()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(NamedCommand))
+                .AddCommand(typeof(NamedSubCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"cmd", "--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Description",
+                "NamedCommand description.",
+                "Usage",
+                "cmd", "[command]", "<param-a>", "[options]",
+                "Parameters",
+                "* param-a", "ParameterA description.",
+                "Options",
+                "-c|--option-c", "OptionC description.",
+                "-d|--option-d", "OptionD description.",
+                "-h|--help", "Shows help text.",
+                "Commands",
+                "sub", "SubCommand description.",
+                "You can run", "to show help on a specific command."
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_can_be_requested_on_a_specific_named_sub_command()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(NamedCommand))
+                .AddCommand(typeof(NamedSubCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"cmd", "sub", "--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Description",
+                "SubCommand description.",
+                "Usage",
+                "cmd sub", "<param-b>", "<param-c>", "[options]",
+                "Parameters",
+                "* param-b", "ParameterB description.",
+                "* param-c", "ParameterC description.",
+                "Options",
+                "-e|--option-e", "OptionE description.",
+                "-h|--help", "Shows help text."
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_can_be_requested_without_specifying_command_even_if_default_command_is_not_defined()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(NamedCommand))
+                .AddCommand(typeof(NamedSubCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Usage",
+                "[command]",
+                "Options",
+                "-h|--help", "Shows help text.",
+                "--version", "Shows version information.",
+                "Commands",
+                "cmd", "NamedCommand description.",
+                "You can run", "to show help on a specific command."
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_shows_usage_format_which_lists_all_parameters()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(ParametersCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"cmd-with-params", "--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Usage",
+                "cmd-with-params", "<first>", "<parameterb>", "<third list...>", "[options]"
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_shows_usage_format_which_lists_all_required_options()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(RequiredOptionsCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"cmd-with-req-opts", "--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Usage",
+                "cmd-with-req-opts", "--option-f <value>", "--option-g <values...>", "[options]",
+                "Options",
+                "* -f|--option-f",
+                "* -g|--option-g",
+                "-h|--option-h"
+            );
+        }
+
+        [Fact]
+        public async Task Help_text_lists_environment_variable_names_for_options_that_have_them_defined()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(EnvironmentVariableCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            await application.RunAsync(new[] {"cmd-with-env-vars", "--help"});
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            stdOutData.Should().ContainAll(
+                "Options",
+                "* -a|--option-a", "Environment variable:", "ENV_OPT_A",
+                "-b|--option-b", "Environment variable:", "ENV_OPT_B"
+            );
+        }
+    }
+}

CliFx.Tests/RoutingSpecs.Commands.cs

@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+
+namespace CliFx.Tests
+{
+    public partial class RoutingSpecs
+    {
+        [Command]
+        private class DefaultCommand : ICommand
+        {
+            public ValueTask ExecuteAsync(IConsole console)
+            {
+                console.Output.WriteLine("Hello world!");
+                return default;
+            }
+        }
+
+        [Command("concat", Description = "Concatenate strings.")]
+        private class ConcatCommand : ICommand
+        {
+            [CommandOption('i', IsRequired = true, Description = "Input strings.")]
+            public IReadOnlyList<string> Inputs { get; set; }
+
+            [CommandOption('s', Description = "String separator.")]
+            public string Separator { get; set; } = "";
+
+            public ValueTask ExecuteAsync(IConsole console)
+            {
+                console.Output.WriteLine(string.Join(Separator, Inputs));
+                return default;
+            }
+        }
+
+        [Command("div", Description = "Divide one number by another.")]
+        private class DivideCommand : ICommand
+        {
+            [CommandOption("dividend", 'D', IsRequired = true, Description = "The number to divide.")]
+            public double Dividend { get; set; }
+
+            [CommandOption("divisor", 'd', IsRequired = true, Description = "The number to divide by.")]
+            public double Divisor { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console)
+            {
+                console.Output.WriteLine(Dividend / Divisor);
+                return default;
+            }
+        }
+    }
+}

CliFx.Tests/RoutingSpecs.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public partial class RoutingSpecs
+    {
+        [Fact]
+        public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(ConcatCommand))
+                .AddCommand(typeof(DivideCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>());
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOutData.Should().Be("Hello world!");
+        }
+
+        [Fact]
+        public async Task Help_text_is_printed_if_no_arguments_were_provided_and_default_command_is_not_defined()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(ConcatCommand))
+                .AddCommand(typeof(DivideCommand))
+                .UseConsole(console)
+                .UseDescription("This will be visible in help")
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>());
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOutData.Should().Contain("This will be visible in help");
+        }
+
+        [Fact]
+        public async Task Specific_named_command_is_executed_if_provided_arguments_match_its_name()
+        {
+            // Arrange
+            await using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(typeof(DefaultCommand))
+                .AddCommand(typeof(ConcatCommand))
+                .AddCommand(typeof(DivideCommand))
+                .UseConsole(console)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"concat", "-i", "foo", "bar", "-s", ", "},
+                new Dictionary<string, string>());
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOutData.Should().Be("foo, bar");
+        }
+    }
+}

CliFx.Tests/TestObjects/TestCommand.cs

@@ -1,18 +0,0 @@
-using CliFx.Attributes;
-using CliFx.Models;
-
-namespace CliFx.Tests.TestObjects
-{
-    [DefaultCommand]
-    [Command("command")]
-    public class TestCommand : Command
-    {
-        [CommandOption("int", ShortName = 'i', IsRequired = true)]
-        public int IntOption { get; set; } = 24;
-
-        [CommandOption("str", ShortName = 's')]
-        public string StringOption { get; set; } = "foo bar";
-
-        public override ExitCode Execute() => new ExitCode(IntOption, StringOption);
-    }
-}

CliFx.Tests/TestObjects/TestEnum.cs

@@ -1,9 +0,0 @@
-namespace CliFx.Tests.TestObjects
-{
-    public enum TestEnum
-    {
-        Value1,
-        Value2,
-        Value3
-    }
-}

CliFx.Tests/UtilitiesSpecs.cs

@@ -0,0 +1,54 @@
+using System.IO;
+using System.Linq;
+using CliFx.Utilities;
+using FluentAssertions;
+using Xunit;
+
+namespace CliFx.Tests
+{
+    public class UtilitiesSpecs
+    {
+        [Fact]
+        public void Progress_ticker_can_be_used_to_report_progress_to_console()
+        {
+            // Arrange
+            using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut, isOutputRedirected: false);
+
+            var ticker = console.CreateProgressTicker();
+
+            var progressValues = Enumerable.Range(0, 100).Select(p => p / 100.0).ToArray();
+            var progressStringValues = progressValues.Select(p => p.ToString("P2")).ToArray();
+
+            // Act
+            foreach (var progress in progressValues)
+                ticker.Report(progress);
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray());
+
+            // Assert
+            stdOutData.Should().ContainAll(progressStringValues);
+        }
+
+        [Fact]
+        public void Progress_ticker_does_not_write_to_console_if_output_is_redirected()
+        {
+            // Arrange
+            using var stdOut = new MemoryStream();
+            var console = new VirtualConsole(output: stdOut);
+
+            var ticker = console.CreateProgressTicker();
+
+            var progressValues = Enumerable.Range(0, 100).Select(p => p / 100.0).ToArray();
+
+            // Act
+            foreach (var progress in progressValues)
+                ticker.Report(progress);
+
+            var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray());
+
+            // Assert
+            stdOutData.Should().BeEmpty();
+        }
+    }
+}

CliFx.Tests/xunit.runner.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+  "methodDisplayOptions": "all",
+  "methodDisplay": "method"
+}

CliFx.props

@@ -0,0 +1,11 @@
+<Project>
+
+  <PropertyGroup>
+    <Version>1.1</Version>
+    <Company>Tyrrrz</Company>
+    <Copyright>Copyright (C) Alexey Golub</Copyright>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

CliFx.sln

@@ -7,15 +7,20 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CliFx", "CliFx\CliFx.csproj
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CliFx.Tests", "CliFx.Tests\CliFx.Tests.csproj", "{268CF863-65A5-49BB-93CF-08972B7756DC}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CliFx.Tests.Dummy", "CliFx.Tests.Dummy\CliFx.Tests.Dummy.csproj", "{4904B3EB-3286-4F1B-8B74-6FF051C8E787}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{3AAE8166-BB8E-49DA-844C-3A0EE6BD40A0}"
 	ProjectSection(SolutionItems) = preProject
 		Changelog.md = Changelog.md
 		License.txt = License.txt
 		Readme.md = Readme.md
+		CliFx.props = CliFx.props
 	EndProjectSection
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CliFx.Benchmarks", "CliFx.Benchmarks\CliFx.Benchmarks.csproj", "{8ACD6DC2-D768-4850-9223-5B7C83A78513}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CliFx.Demo", "CliFx.Demo\CliFx.Demo.csproj", "{AAB6844C-BF71-448F-A11B-89AEE459AB15}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CliFx.Tests.Dummy", "CliFx.Tests.Dummy\CliFx.Tests.Dummy.csproj", "{F717347D-8656-44DA-A4A2-BE515E8C4655}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -50,18 +55,42 @@ Global
 		{268CF863-65A5-49BB-93CF-08972B7756DC}.Release|x64.Build.0 = Release|Any CPU
 		{268CF863-65A5-49BB-93CF-08972B7756DC}.Release|x86.ActiveCfg = Release|Any CPU
 		{268CF863-65A5-49BB-93CF-08972B7756DC}.Release|x86.Build.0 = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|x64.Build.0 = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|x64.Build.0 = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Debug|x86.Build.0 = Debug|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Debug|x86.Build.0 = Debug|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|Any CPU.Build.0 = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|x64.ActiveCfg = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|x64.ActiveCfg = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|x64.Build.0 = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|x64.Build.0 = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|x86.ActiveCfg = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|x86.ActiveCfg = Release|Any CPU
-		{4904B3EB-3286-4F1B-8B74-6FF051C8E787}.Release|x86.Build.0 = Release|Any CPU
+		{8ACD6DC2-D768-4850-9223-5B7C83A78513}.Release|x86.Build.0 = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|x64.Build.0 = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Debug|x86.Build.0 = Debug|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|Any CPU.Build.0 = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|x64.ActiveCfg = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|x64.Build.0 = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|x86.ActiveCfg = Release|Any CPU
+		{AAB6844C-BF71-448F-A11B-89AEE459AB15}.Release|x86.Build.0 = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|x64.Build.0 = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Debug|x86.Build.0 = Debug|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|x64.ActiveCfg = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|x64.Build.0 = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|x86.ActiveCfg = Release|Any CPU
+		{F717347D-8656-44DA-A4A2-BE515E8C4655}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

CliFx/ApplicationConfiguration.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Configuration of an application.
+    /// </summary>
+    public class ApplicationConfiguration
+    {
+        /// <summary>
+        /// Command types defined in this application.
+        /// </summary>
+        public IReadOnlyList<Type> CommandTypes { get; }
+
+        /// <summary>
+        /// Whether debug mode is allowed in this application.
+        /// </summary>
+        public bool IsDebugModeAllowed { get; }
+
+        /// <summary>
+        /// Whether preview mode is allowed in this application.
+        /// </summary>
+        public bool IsPreviewModeAllowed { get; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="ApplicationConfiguration"/>.
+        /// </summary>
+        public ApplicationConfiguration(
+            IReadOnlyList<Type> commandTypes,
+            bool isDebugModeAllowed, bool isPreviewModeAllowed)
+        {
+            CommandTypes = commandTypes;
+            IsDebugModeAllowed = isDebugModeAllowed;
+            IsPreviewModeAllowed = isPreviewModeAllowed;
+        }
+    }
+}

CliFx/ApplicationMetadata.cs

@@ -0,0 +1,39 @@
+namespace CliFx
+{
+    /// <summary>
+    /// Metadata associated with an application.
+    /// </summary>
+    public class ApplicationMetadata
+    {
+        /// <summary>
+        /// Application title.
+        /// </summary>
+        public string Title { get; }
+
+        /// <summary>
+        /// Application executable name.
+        /// </summary>
+        public string ExecutableName { get; }
+
+        /// <summary>
+        /// Application version text.
+        /// </summary>
+        public string VersionText { get; }
+
+        /// <summary>
+        /// Application description.
+        /// </summary>
+        public string? Description { get; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="ApplicationMetadata"/>.
+        /// </summary>
+        public ApplicationMetadata(string title, string executableName, string versionText, string? description)
+        {
+            Title = title;
+            ExecutableName = executableName;
+            VersionText = versionText;
+            Description = description;
+        }
+    }
+}

CliFx/Attributes/CommandAttribute.cs

@@ -2,14 +2,38 @@
 
 namespace CliFx.Attributes
 {
+    /// <summary>
+    /// Annotates a type that defines a command.
+    /// </summary>
     [AttributeUsage(AttributeTargets.Class, Inherited = false)]
     public class CommandAttribute : Attribute
     {
-        public string Name { get; }
+        /// <summary>
+        /// Command name.
+        /// If the name is not set, the command is treated as a default command, i.e. the one that gets executed when the user
+        /// does not specify a command name in the arguments.
+        /// All commands in an application must have different names. Likewise, only one command without a name is allowed.
+        /// </summary>
+        public string? Name { get; }
 
+        /// <summary>
+        /// Command description, which is used in help text.
+        /// </summary>
+        public string? Description { get; set; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandAttribute"/>.
+        /// </summary>
         public CommandAttribute(string name)
         {
             Name = name;
         }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandAttribute"/>.
+        /// </summary>
+        public CommandAttribute()
+        {
+        }
     }
 }

CliFx/Attributes/CommandOptionAttribute.cs

@@ -2,20 +2,72 @@
 
 namespace CliFx.Attributes
 {
+    /// <summary>
+    /// Annotates a property that defines a command option.
+    /// </summary>
     [AttributeUsage(AttributeTargets.Property)]
     public class CommandOptionAttribute : Attribute
     {
-        public string Name { get; }
+        /// <summary>
+        /// Option name.
+        /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+        /// All options in a command must have different names (comparison is not case-sensitive).
+        /// </summary>
+        public string? Name { get; }
 
-        public char ShortName { get; set; }
+        /// <summary>
+        /// Option short name.
+        /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+        /// All options in a command must have different short names (comparison is case-sensitive).
+        /// </summary>
+        public char? ShortName { get; }
 
+        /// <summary>
+        /// Whether an option is required.
+        /// </summary>
         public bool IsRequired { get; set; }
 
-        public string Description { get; set; }
+        /// <summary>
+        /// Option description, which is used in help text.
+        /// </summary>
+        public string? Description { get; set; }
 
-        public CommandOptionAttribute(string name)
+        /// <summary>
+        /// Environment variable that will be used as fallback if no option value is specified.
+        /// </summary>
+        public string? EnvironmentVariableName { get; set; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+        /// </summary>
+        private CommandOptionAttribute(string? name, char? shortName)
         {
             Name = name;
+            ShortName = shortName;
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+        /// </summary>
+        public CommandOptionAttribute(string name, char shortName)
+            : this(name, (char?) shortName)
+        {
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+        /// </summary>
+        public CommandOptionAttribute(string name)
+            : this(name, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+        /// </summary>
+        public CommandOptionAttribute(char shortName)
+            : this(null, (char?) shortName)
+        {
         }
     }
 }

CliFx/Attributes/CommandParameterAttribute.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace CliFx.Attributes
+{
+    /// <summary>
+    /// Annotates a property that defines a command parameter.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class CommandParameterAttribute : Attribute
+    {
+        /// <summary>
+        /// Order of this parameter compared to other parameters.
+        /// All parameters in a command must have different order.
+        /// Parameter whose type is a non-scalar (e.g. array), must be the last in order and only one such parameter is allowed.
+        /// </summary>
+        public int Order { get; }
+
+        /// <summary>
+        /// Parameter name, which is only used in help text.
+        /// If this isn't specified, property name is used instead.
+        /// </summary>
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// Parameter description, which is used in help text.
+        /// </summary>
+        public string? Description { get; set; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandParameterAttribute"/>.
+        /// </summary>
+        public CommandParameterAttribute(int order)
+        {
+            Order = order;
+        }
+    }
+}

CliFx/Attributes/DefaultCommandAttribute.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace CliFx.Attributes
-{
-    [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-    public class DefaultCommandAttribute : Attribute
-    {
-    }
-}

CliFx/CliApplication.cs

@@ -1,45 +1,209 @@
-using System.Collections.Generic;
+using System;
-using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using System.Threading.Tasks;
-using CliFx.Services;
+using CliFx.Domain;
+using CliFx.Exceptions;
 
 namespace CliFx
 {
-    public partial class CliApplication : ICliApplication
+    /// <summary>
+    /// Command line application facade.
+    /// </summary>
+    public class CliApplication
     {
-        private readonly ICommandResolver _commandResolver;
+        private readonly ApplicationMetadata _metadata;
+        private readonly ApplicationConfiguration _configuration;
+        private readonly IConsole _console;
+        private readonly ITypeActivator _typeActivator;
 
-        public CliApplication(ICommandResolver commandResolver)
+        private readonly HelpTextWriter _helpTextWriter;
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CliApplication"/>.
+        /// </summary>
+        public CliApplication(
+            ApplicationMetadata metadata, ApplicationConfiguration configuration,
+            IConsole console, ITypeActivator typeActivator)
         {
-            _commandResolver = commandResolver;
+            _metadata = metadata;
+            _configuration = configuration;
+            _console = console;
+            _typeActivator = typeActivator;
+
+            _helpTextWriter = new HelpTextWriter(metadata, console);
         }
 
-        public CliApplication()
+        private async ValueTask<int?> HandleDebugDirectiveAsync(CommandLineInput commandLineInput)
-            : this(GetDefaultCommandResolver(Assembly.GetCallingAssembly()))
         {
+            var isDebugMode = _configuration.IsDebugModeAllowed && commandLineInput.IsDebugDirectiveSpecified;
+            if (!isDebugMode)
+                return null;
+
+            _console.WithForegroundColor(ConsoleColor.Green, () =>
+                _console.Output.WriteLine($"Attach debugger to PID {Process.GetCurrentProcess().Id} to continue."));
+
+            while (!Debugger.IsAttached)
+                await Task.Delay(100);
+
+            return null;
         }
 
-        public async Task<int> RunAsync(IReadOnlyList<string> commandLineArguments)
+        private int? HandlePreviewDirective(ApplicationSchema applicationSchema, CommandLineInput commandLineInput)
         {
-            // Resolve and execute command
+            var isPreviewMode = _configuration.IsPreviewModeAllowed && commandLineInput.IsPreviewDirectiveSpecified;
-            var command = _commandResolver.ResolveCommand(commandLineArguments);
+            if (!isPreviewMode)
-            var exitCode = await command.ExecuteAsync();
+                return null;
 
-            // TODO: print message if error?
+            var commandSchema = applicationSchema.TryFindCommand(commandLineInput, out var argumentOffset);
 
-            return exitCode.Value;
+            _console.Output.WriteLine("Parser preview:");
-        }
-    }
 
-    public partial class CliApplication
+            // Command name
+            if (commandSchema != null && argumentOffset > 0)
             {
-        private static ICommandResolver GetDefaultCommandResolver(Assembly assembly)
+                _console.WithForegroundColor(ConsoleColor.Cyan, () =>
-        {
+                    _console.Output.Write(commandSchema.Name));
-            var typeProvider = TypeProvider.FromAssembly(assembly);
-            var commandOptionParser = new CommandOptionParser();
-            var commandOptionConverter = new CommandOptionConverter();
 
-            return new CommandResolver(typeProvider, commandOptionParser, commandOptionConverter);
+                _console.Output.Write(' ');
+            }
+
+            // Parameters
+            foreach (var parameter in commandLineInput.UnboundArguments.Skip(argumentOffset))
+            {
+                _console.Output.Write('<');
+
+                _console.WithForegroundColor(ConsoleColor.White, () =>
+                    _console.Output.Write(parameter));
+
+                _console.Output.Write('>');
+                _console.Output.Write(' ');
+            }
+
+            // Options
+            foreach (var option in commandLineInput.Options)
+            {
+                _console.Output.Write('[');
+
+                _console.WithForegroundColor(ConsoleColor.White, () =>
+                    _console.Output.Write(option));
+
+                _console.Output.Write(']');
+                _console.Output.Write(' ');
+            }
+
+            _console.Output.WriteLine();
+
+            return 0;
+        }
+
+        private int? HandleVersionOption(CommandLineInput commandLineInput)
+        {
+            // Version option is available only on the default command (i.e. when arguments are not specified)
+            var shouldRenderVersion = !commandLineInput.UnboundArguments.Any() && commandLineInput.IsVersionOptionSpecified;
+            if (!shouldRenderVersion)
+                return null;
+
+            _console.Output.WriteLine(_metadata.VersionText);
+
+            return 0;
+        }
+
+        private int? HandleHelpOption(ApplicationSchema applicationSchema, CommandLineInput commandLineInput)
+        {
+            // Help is rendered either when it's requested or when the user provides no arguments and there is no default command
+            var shouldRenderHelp =
+                commandLineInput.IsHelpOptionSpecified ||
+                !applicationSchema.Commands.Any(c => c.IsDefault) && !commandLineInput.UnboundArguments.Any() && !commandLineInput.Options.Any();
+
+            if (!shouldRenderHelp)
+                return null;
+
+            // Get the command schema that matches the input or use a dummy default command as a fallback
+            var commandSchema =
+                applicationSchema.TryFindCommand(commandLineInput) ??
+                CommandSchema.StubDefaultCommand;
+
+            _helpTextWriter.Write(applicationSchema, commandSchema);
+
+            return 0;
+        }
+
+        private async ValueTask<int> HandleCommandExecutionAsync(
+            ApplicationSchema applicationSchema,
+            CommandLineInput commandLineInput,
+            IReadOnlyDictionary<string, string> environmentVariables)
+        {
+            await applicationSchema
+                .InitializeEntryPoint(commandLineInput, environmentVariables, _typeActivator)
+                .ExecuteAsync(_console);
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Runs the application with specified command line arguments and environment variables, and returns the exit code.
+        /// </summary>
+        public async ValueTask<int> RunAsync(
+            IReadOnlyList<string> commandLineArguments,
+            IReadOnlyDictionary<string, string> environmentVariables)
+        {
+            try
+            {
+                var applicationSchema = ApplicationSchema.Resolve(_configuration.CommandTypes);
+                var commandLineInput = CommandLineInput.Parse(commandLineArguments);
+
+                return
+                    await HandleDebugDirectiveAsync(commandLineInput) ??
+                    HandlePreviewDirective(applicationSchema, commandLineInput) ??
+                    HandleVersionOption(commandLineInput) ??
+                    HandleHelpOption(applicationSchema, commandLineInput) ??
+                    await HandleCommandExecutionAsync(applicationSchema, commandLineInput, environmentVariables);
+            }
+            catch (Exception ex)
+            {
+                // We want to catch exceptions in order to print errors and return correct exit codes.
+                // Doing this also gets rid of the annoying Windows troubleshooting dialog that shows up on unhandled exceptions.
+
+                // Prefer showing message without stack trace on exceptions coming from CliFx or on CommandException
+                var errorMessage = !string.IsNullOrWhiteSpace(ex.Message) && (ex is CliFxException || ex is CommandException)
+                    ? ex.Message
+                    : ex.ToString();
+
+                _console.WithForegroundColor(ConsoleColor.Red, () => _console.Error.WriteLine(errorMessage));
+
+                return ex is CommandException commandException
+                    ? commandException.ExitCode
+                    : ex.HResult;
+            }
+        }
+
+        /// <summary>
+        /// Runs the application with specified command line arguments and returns the exit code.
+        /// Environment variables are retrieved automatically.
+        /// </summary>
+        public async ValueTask<int> RunAsync(IReadOnlyList<string> commandLineArguments)
+        {
+            var environmentVariables = Environment.GetEnvironmentVariables()
+                .Cast<DictionaryEntry>()
+                .ToDictionary(e => (string) e.Key, e => (string) e.Value, StringComparer.OrdinalIgnoreCase);
+
+            return await RunAsync(commandLineArguments, environmentVariables);
+        }
+
+        /// <summary>
+        /// Runs the application and returns the exit code.
+        /// Command line arguments and environment variables are retrieved automatically.
+        /// </summary>
+        public async ValueTask<int> RunAsync()
+        {
+            var commandLineArguments = Environment.GetCommandLineArgs()
+                .Skip(1)
+                .ToArray();
+
+            return await RunAsync(commandLineArguments);
         }
     }
 }

CliFx/CliApplicationBuilder.cs

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using CliFx.Domain;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Builds an instance of <see cref="CliApplication"/>.
+    /// </summary>
+    public partial class CliApplicationBuilder
+    {
+        private readonly HashSet<Type> _commandTypes = new HashSet<Type>();
+
+        private bool _isDebugModeAllowed = true;
+        private bool _isPreviewModeAllowed = true;
+        private string? _title;
+        private string? _executableName;
+        private string? _versionText;
+        private string? _description;
+        private IConsole? _console;
+        private ITypeActivator? _typeActivator;
+
+        /// <summary>
+        /// Adds a command of specified type to the application.
+        /// </summary>
+        public CliApplicationBuilder AddCommand(Type commandType)
+        {
+            _commandTypes.Add(commandType);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds multiple commands to the application.
+        /// </summary>
+        public CliApplicationBuilder AddCommands(IEnumerable<Type> commandTypes)
+        {
+            foreach (var commandType in commandTypes)
+                AddCommand(commandType);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds commands from the specified assembly to the application.
+        /// Only adds public valid command types.
+        /// </summary>
+        public CliApplicationBuilder AddCommandsFrom(Assembly commandAssembly)
+        {
+            foreach (var commandType in commandAssembly.ExportedTypes.Where(CommandSchema.IsCommandType))
+                AddCommand(commandType);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds commands from the specified assemblies to the application.
+        /// Only adds public valid command types.
+        /// </summary>
+        public CliApplicationBuilder AddCommandsFrom(IEnumerable<Assembly> commandAssemblies)
+        {
+            foreach (var commandAssembly in commandAssemblies)
+                AddCommandsFrom(commandAssembly);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Adds commands from the calling assembly to the application.
+        /// Only adds public valid command types.
+        /// </summary>
+        public CliApplicationBuilder AddCommandsFromThisAssembly() => AddCommandsFrom(Assembly.GetCallingAssembly());
+
+        /// <summary>
+        /// Specifies whether debug mode (enabled with [debug] directive) is allowed in the application.
+        /// </summary>
+        public CliApplicationBuilder AllowDebugMode(bool isAllowed = true)
+        {
+            _isDebugModeAllowed = isAllowed;
+            return this;
+        }
+
+        /// <summary>
+        /// Specifies whether preview mode (enabled with [preview] directive) is allowed in the application.
+        /// </summary>
+        public CliApplicationBuilder AllowPreviewMode(bool isAllowed = true)
+        {
+            _isPreviewModeAllowed = isAllowed;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets application title, which appears in the help text.
+        /// </summary>
+        public CliApplicationBuilder UseTitle(string title)
+        {
+            _title = title;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets application executable name, which appears in the help text.
+        /// </summary>
+        public CliApplicationBuilder UseExecutableName(string executableName)
+        {
+            _executableName = executableName;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets application version text, which appears in the help text and when the user requests version information.
+        /// </summary>
+        public CliApplicationBuilder UseVersionText(string versionText)
+        {
+            _versionText = versionText;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets application description, which appears in the help text.
+        /// </summary>
+        public CliApplicationBuilder UseDescription(string? description)
+        {
+            _description = description;
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the application to use the specified implementation of <see cref="IConsole"/>.
+        /// </summary>
+        public CliApplicationBuilder UseConsole(IConsole console)
+        {
+            _console = console;
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the application to use the specified implementation of <see cref="ITypeActivator"/>.
+        /// </summary>
+        public CliApplicationBuilder UseTypeActivator(ITypeActivator typeActivator)
+        {
+            _typeActivator = typeActivator;
+            return this;
+        }
+
+        /// <summary>
+        /// Configures the application to use the specified function for activating types.
+        /// </summary>
+        public CliApplicationBuilder UseTypeActivator(Func<Type, object> typeActivator) =>
+            UseTypeActivator(new DelegateTypeActivator(typeActivator));
+
+        /// <summary>
+        /// Creates an instance of <see cref="CliApplication"/> using configured parameters.
+        /// Default values are used in place of parameters that were not specified.
+        /// </summary>
+        public CliApplication Build()
+        {
+            _title ??= GetDefaultTitle() ?? "App";
+            _executableName ??= GetDefaultExecutableName() ?? "app";
+            _versionText ??= GetDefaultVersionText() ?? "v1.0";
+            _console ??= new SystemConsole();
+            _typeActivator ??= new DefaultTypeActivator();
+
+            var metadata = new ApplicationMetadata(_title, _executableName, _versionText, _description);
+            var configuration = new ApplicationConfiguration(_commandTypes.ToArray(), _isDebugModeAllowed, _isPreviewModeAllowed);
+
+            return new CliApplication(metadata, configuration, _console, _typeActivator);
+        }
+    }
+
+    public partial class CliApplicationBuilder
+    {
+        private static readonly Lazy<Assembly> LazyEntryAssembly = new Lazy<Assembly>(Assembly.GetEntryAssembly);
+
+        // Entry assembly is null in tests
+        private static Assembly EntryAssembly => LazyEntryAssembly.Value;
+
+        private static string? GetDefaultTitle() => EntryAssembly?.GetName().Name;
+
+        private static string? GetDefaultExecutableName()
+        {
+            var entryAssemblyLocation = EntryAssembly?.Location;
+
+            // If it's a .dll assembly, prepend 'dotnet' and keep the file extension
+            if (string.Equals(Path.GetExtension(entryAssemblyLocation), ".dll", StringComparison.OrdinalIgnoreCase))
+            {
+                return "dotnet " + Path.GetFileName(entryAssemblyLocation);
+            }
+
+            // Otherwise just use assembly file name without extension
+            return Path.GetFileNameWithoutExtension(entryAssemblyLocation);
+        }
+
+        private static string? GetDefaultVersionText() =>
+            EntryAssembly != null
+                ? $"v{EntryAssembly.GetName().Version}"
+                : null;
+    }
+}

CliFx/CliFx.csproj

@@ -1,23 +1,44 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
-    <TargetFrameworks>net45;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;netstandard2.0;net45</TargetFrameworks>
-    <LangVersion>latest</LangVersion>
-    <Version>0.0.1</Version>
-    <Company>Tyrrrz</Company>
     <Authors>$(Company)</Authors>
-    <Copyright>Copyright (C) Alexey Golub</Copyright>
     <Description>Declarative framework for CLI applications</Description>
     <PackageTags>command line executable interface framework parser arguments net core</PackageTags>
     <PackageProjectUrl>https://github.com/Tyrrrz/CliFx</PackageProjectUrl>
     <PackageReleaseNotes>https://github.com/Tyrrrz/CliFx/blob/master/Changelog.md</PackageReleaseNotes>
-    <PackageIconUrl>https://raw.githubusercontent.com/Tyrrrz/CliFx/master/favicon.png</PackageIconUrl>
+    <PackageIcon>favicon.png</PackageIcon>
-    <PackageLicenseExpression>LGPL-3.0-only</PackageLicenseExpression>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <RepositoryUrl>https://github.com/Tyrrrz/CliFx</RepositoryUrl>
-    <RepositoryType>git</RepositoryType>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
-    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
-    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
+    <PublishRepositoryUrl>True</PublishRepositoryUrl>
+    <EmbedUntrackedSources>True</EmbedUntrackedSources>
+    <IncludeSymbols>True</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
   </PropertyGroup>
 
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>$(AssemblyName).Tests</_Parameter1>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>$(AssemblyName).Analyzers</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="../favicon.png" Pack="True" PackagePath="" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="all" />
+    <PackageReference Include="Nullable" Version="1.2.1" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net45'">
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.3" />
+  </ItemGroup>
+
 </Project>

CliFx/Command.cs

@@ -1,15 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using CliFx.Models;
-
-namespace CliFx
-{
-    public abstract class Command
-    {
-        public virtual ExitCode Execute() => throw new InvalidOperationException(
-            "Can't execute command because its execution method is not defined. " +
-            $"Override Execute or ExecuteAsync on {GetType().Name} in order to make it executable.");
-
-        public virtual Task<ExitCode> ExecuteAsync() => Task.FromResult(Execute());
-    }
-}

CliFx/DefaultTypeActivator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Text;
+using CliFx.Exceptions;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Type activator that uses the <see cref="Activator"/> class to instantiate objects.
+    /// </summary>
+    public class DefaultTypeActivator : ITypeActivator
+    {
+        /// <inheritdoc />
+        public object CreateInstance(Type type)
+        {
+            try
+            {
+                return Activator.CreateInstance(type);
+            }
+            catch (Exception ex)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .Append($"Failed to create an instance of {type.FullName}.").Append(" ")
+                    .AppendLine("The type must have a public parameter-less constructor in order to be instantiated by the default activator.")
+                    .Append($"To supply a custom activator (for example when using dependency injection), call {nameof(CliApplicationBuilder)}.{nameof(CliApplicationBuilder.UseTypeActivator)}(...).")
+                    .ToString(), ex);
+            }
+        }
+    }
+}

CliFx/DelegateTypeActivator.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Text;
+using CliFx.Exceptions;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Type activator that uses the specified delegate to instantiate objects.
+    /// </summary>
+    public class DelegateTypeActivator : ITypeActivator
+    {
+        private readonly Func<Type, object> _func;
+
+        /// <summary>
+        /// Initializes an instance of <see cref="DelegateTypeActivator"/>.
+        /// </summary>
+        public DelegateTypeActivator(Func<Type, object> func) => _func = func;
+
+        /// <inheritdoc />
+        public object CreateInstance(Type type) =>
+            _func(type) ?? throw new CliFxException(new StringBuilder()
+                .Append($"Failed to create an instance of type {type.FullName}, received <null> instead.").Append(" ")
+                .Append("Make sure that the provided type activator was configured correctly.").Append(" ")
+                .Append("If you are using a dependency container, make sure that this type is registered.")
+                .ToString());
+    }
+}

CliFx/Domain/ApplicationSchema.cs

@@ -0,0 +1,267 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CliFx.Attributes;
+using CliFx.Exceptions;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal partial class ApplicationSchema
+    {
+        public IReadOnlyList<CommandSchema> Commands { get; }
+
+        public ApplicationSchema(IReadOnlyList<CommandSchema> commands)
+        {
+            Commands = commands;
+        }
+
+        public CommandSchema? TryFindParentCommand(string? childCommandName)
+        {
+            // Default command has no parent
+            if (string.IsNullOrWhiteSpace(childCommandName))
+                return null;
+
+            // Try to find the parent command by repeatedly biting off chunks of its name
+            var route = childCommandName.Split(' ');
+            for (var i = route.Length - 1; i >= 1; i--)
+            {
+                var potentialParentCommandName = string.Join(" ", route.Take(i));
+                var matchingParentCommand = Commands.FirstOrDefault(c => c.MatchesName(potentialParentCommandName));
+
+                if (matchingParentCommand != null)
+                    return matchingParentCommand;
+            }
+
+            // If there's no parent - fall back to default command
+            return Commands.FirstOrDefault(c => c.IsDefault);
+        }
+
+        public IReadOnlyList<CommandSchema> GetChildCommands(string? parentCommandName) =>
+            !string.IsNullOrWhiteSpace(parentCommandName) || Commands.Any(c => c.IsDefault)
+                ? Commands.Where(c => TryFindParentCommand(c.Name)?.MatchesName(parentCommandName) == true).ToArray()
+                : Commands.Where(c => !string.IsNullOrWhiteSpace(c.Name) && TryFindParentCommand(c.Name) == null).ToArray();
+
+        // TODO: this out parameter is not a really nice design
+        public CommandSchema? TryFindCommand(CommandLineInput commandLineInput, out int argumentOffset)
+        {
+            // Try to find the command that contains the most of the input arguments in its name
+            for (var i = commandLineInput.UnboundArguments.Count; i >= 0; i--)
+            {
+                var potentialCommandName = string.Join(" ", commandLineInput.UnboundArguments.Take(i));
+                var matchingCommand = Commands.FirstOrDefault(c => c.MatchesName(potentialCommandName));
+
+                if (matchingCommand != null)
+                {
+                    argumentOffset = i;
+                    return matchingCommand;
+                }
+            }
+
+            argumentOffset = 0;
+            return Commands.FirstOrDefault(c => c.IsDefault);
+        }
+
+        public CommandSchema? TryFindCommand(CommandLineInput commandLineInput) =>
+            TryFindCommand(commandLineInput, out _);
+
+        public ICommand InitializeEntryPoint(
+            CommandLineInput commandLineInput,
+            IReadOnlyDictionary<string, string> environmentVariables,
+            ITypeActivator activator)
+        {
+            var command = TryFindCommand(commandLineInput, out var argumentOffset);
+            if (command == null)
+            {
+                throw new CliFxException(
+                    $"Can't find a command that matches arguments [{string.Join(" ", commandLineInput.UnboundArguments)}].");
+            }
+
+            var parameterValues = argumentOffset == 0
+                ? commandLineInput.UnboundArguments.Select(a => a.Value).ToArray()
+                : commandLineInput.UnboundArguments.Skip(argumentOffset).Select(a => a.Value).ToArray();
+
+            return command.CreateInstance(parameterValues, commandLineInput.Options, environmentVariables, activator);
+        }
+
+        public ICommand InitializeEntryPoint(
+            CommandLineInput commandLineInput,
+            IReadOnlyDictionary<string, string> environmentVariables) =>
+            InitializeEntryPoint(commandLineInput, environmentVariables, new DefaultTypeActivator());
+
+        public ICommand InitializeEntryPoint(CommandLineInput commandLineInput) =>
+            InitializeEntryPoint(commandLineInput, new Dictionary<string, string>());
+
+        public override string ToString() => string.Join(Environment.NewLine, Commands);
+    }
+
+    internal partial class ApplicationSchema
+    {
+        private static void ValidateParameters(CommandSchema command)
+        {
+            var duplicateOrderGroup = command.Parameters
+                .GroupBy(a => a.Order)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateOrderGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains two or more parameters that have the same order ({duplicateOrderGroup.Key}):")
+                    .AppendBulletList(duplicateOrderGroup.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .Append("Parameters in a command must all have unique order.")
+                    .ToString());
+            }
+
+            var duplicateNameGroup = command.Parameters
+                .Where(a => !string.IsNullOrWhiteSpace(a.Name))
+                .GroupBy(a => a.Name, StringComparer.OrdinalIgnoreCase)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateNameGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains two or more parameters that have the same name ({duplicateNameGroup.Key}):")
+                    .AppendBulletList(duplicateNameGroup.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .Append("Parameters in a command must all have unique names.").Append(" ")
+                    .Append("Comparison is NOT case-sensitive.")
+                    .ToString());
+            }
+
+            var nonScalarParameters = command.Parameters
+                .Where(p => !p.IsScalar)
+                .ToArray();
+
+            if (nonScalarParameters.Length > 1)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command [{command.Type.FullName}] contains two or more parameters of an enumerable type:")
+                    .AppendBulletList(nonScalarParameters.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .AppendLine("There can only be one parameter of an enumerable type in a command.")
+                    .Append("Note, the string type is not considered enumerable in this context.")
+                    .ToString());
+            }
+
+            var nonLastNonScalarParameter = command.Parameters
+                .OrderByDescending(a => a.Order)
+                .Skip(1)
+                .LastOrDefault(p => !p.IsScalar);
+
+            if (nonLastNonScalarParameter != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains a parameter of an enumerable type which doesn't appear last in order:")
+                    .AppendLine($"- {nonLastNonScalarParameter.Property.Name}")
+                    .AppendLine()
+                    .Append("Parameter of an enumerable type must always come last to avoid ambiguity.")
+                    .ToString());
+            }
+        }
+
+        private static void ValidateOptions(CommandSchema command)
+        {
+            var duplicateNameGroup = command.Options
+                .Where(o => !string.IsNullOrWhiteSpace(o.Name))
+                .GroupBy(o => o.Name, StringComparer.OrdinalIgnoreCase)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateNameGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains two or more options that have the same name ({duplicateNameGroup.Key}):")
+                    .AppendBulletList(duplicateNameGroup.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .Append("Options in a command must all have unique names.").Append(" ")
+                    .Append("Comparison is NOT case-sensitive.")
+                    .ToString());
+            }
+
+            var duplicateShortNameGroup = command.Options
+                .Where(o => o.ShortName != null)
+                .GroupBy(o => o.ShortName)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateShortNameGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains two or more options that have the same short name ({duplicateShortNameGroup.Key}):")
+                    .AppendBulletList(duplicateShortNameGroup.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .Append("Options in a command must all have unique short names.").Append(" ")
+                    .Append("Comparison is case-sensitive.")
+                    .ToString());
+            }
+
+            var duplicateEnvironmentVariableNameGroup = command.Options
+                .Where(o => !string.IsNullOrWhiteSpace(o.EnvironmentVariableName))
+                .GroupBy(o => o.EnvironmentVariableName, StringComparer.OrdinalIgnoreCase)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateEnvironmentVariableNameGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Command {command.Type.FullName} contains two or more options that have the same environment variable name ({duplicateEnvironmentVariableNameGroup.Key}):")
+                    .AppendBulletList(duplicateEnvironmentVariableNameGroup.Select(o => o.Property.Name))
+                    .AppendLine()
+                    .Append("Options in a command must all have unique environment variable names.").Append(" ")
+                    .Append("Comparison is NOT case-sensitive.")
+                    .ToString());
+            }
+        }
+
+        private static void ValidateCommands(IReadOnlyList<CommandSchema> commands)
+        {
+            if (!commands.Any())
+            {
+                throw new CliFxException("There are no commands configured for this application.");
+            }
+
+            var duplicateNameGroup = commands
+                .GroupBy(c => c.Name, StringComparer.OrdinalIgnoreCase)
+                .FirstOrDefault(g => g.Count() > 1);
+
+            if (duplicateNameGroup != null)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Application contains two or more commands that have the same name ({duplicateNameGroup.Key}):")
+                    .AppendBulletList(duplicateNameGroup.Select(o => o.Type.FullName))
+                    .AppendLine()
+                    .Append("Commands must all have unique names. Likewise, there must not be more than one command without a name.").Append(" ")
+                    .Append("Comparison is NOT case-sensitive.")
+                    .ToString());
+            }
+        }
+
+        public static ApplicationSchema Resolve(IReadOnlyList<Type> commandTypes)
+        {
+            var commands = new List<CommandSchema>();
+
+            foreach (var commandType in commandTypes)
+            {
+                var command = CommandSchema.TryResolve(commandType);
+                if (command == null)
+                {
+                    throw new CliFxException(new StringBuilder()
+                        .Append($"Command {commandType.FullName} is not a valid command type.").Append(" ")
+                        .AppendLine("In order to be a valid command type it must:")
+                        .AppendLine($" - Be annotated with {typeof(CommandAttribute).FullName}")
+                        .AppendLine($" - Implement {typeof(ICommand).FullName}")
+                        .AppendLine(" - Not be an abstract class")
+                        .ToString());
+                }
+
+                ValidateParameters(command);
+                ValidateOptions(command);
+
+                commands.Add(command);
+            }
+
+            ValidateCommands(commands);
+
+            return new ApplicationSchema(commands);
+        }
+    }
+}

CliFx/Domain/CommandArgumentSchema.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using CliFx.Exceptions;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal abstract partial class CommandArgumentSchema
+    {
+        public PropertyInfo Property { get; }
+
+        public string? Description { get; }
+
+        public bool IsScalar => GetEnumerableArgumentUnderlyingType() == null;
+
+        protected CommandArgumentSchema(PropertyInfo property, string? description)
+        {
+            Property = property;
+            Description = description;
+        }
+
+        private Type? GetEnumerableArgumentUnderlyingType() =>
+            Property.PropertyType != typeof(string)
+                ? Property.PropertyType.GetEnumerableUnderlyingType()
+                : null;
+
+        private object Convert(IReadOnlyList<string> values)
+        {
+            var targetType = Property.PropertyType;
+            var enumerableUnderlyingType = GetEnumerableArgumentUnderlyingType();
+
+            // Scalar
+            if (enumerableUnderlyingType == null)
+            {
+                if (values.Count > 1)
+                {
+                    throw new CliFxException(new StringBuilder()
+                        .AppendLine($"Can't convert a sequence of values [{string.Join(", ", values)}] to type {targetType.FullName}.")
+                        .Append("Target type is not enumerable and can't accept more than one value.")
+                        .ToString());
+                }
+
+                return ConvertScalar(values.SingleOrDefault(), targetType);
+            }
+            // Non-scalar
+            else
+            {
+                return ConvertNonScalar(values, targetType, enumerableUnderlyingType);
+            }
+        }
+
+        public void Inject(ICommand command, IReadOnlyList<string> values) =>
+            Property.SetValue(command, Convert(values));
+
+        public void Inject(ICommand command, params string[] values) =>
+            Inject(command, (IReadOnlyList<string>) values);
+    }
+
+    internal partial class CommandArgumentSchema
+    {
+        private static readonly IFormatProvider ConversionFormatProvider = CultureInfo.InvariantCulture;
+
+        private static readonly IReadOnlyDictionary<Type, Func<string, object>> PrimitiveConverters =
+            new Dictionary<Type, Func<string?, object>>
+            {
+                [typeof(object)] = v => v,
+                [typeof(string)] = v => v,
+                [typeof(bool)] = v => string.IsNullOrWhiteSpace(v) || bool.Parse(v),
+                [typeof(char)] = v => v.Single(),
+                [typeof(sbyte)] = v => sbyte.Parse(v, ConversionFormatProvider),
+                [typeof(byte)] = v => byte.Parse(v, ConversionFormatProvider),
+                [typeof(short)] = v => short.Parse(v, ConversionFormatProvider),
+                [typeof(ushort)] = v => ushort.Parse(v, ConversionFormatProvider),
+                [typeof(int)] = v => int.Parse(v, ConversionFormatProvider),
+                [typeof(uint)] = v => uint.Parse(v, ConversionFormatProvider),
+                [typeof(long)] = v => long.Parse(v, ConversionFormatProvider),
+                [typeof(ulong)] = v => ulong.Parse(v, ConversionFormatProvider),
+                [typeof(float)] = v => float.Parse(v, ConversionFormatProvider),
+                [typeof(double)] = v => double.Parse(v, ConversionFormatProvider),
+                [typeof(decimal)] = v => decimal.Parse(v, ConversionFormatProvider),
+                [typeof(DateTime)] = v => DateTime.Parse(v, ConversionFormatProvider),
+                [typeof(DateTimeOffset)] = v => DateTimeOffset.Parse(v, ConversionFormatProvider),
+                [typeof(TimeSpan)] = v => TimeSpan.Parse(v, ConversionFormatProvider),
+            };
+
+        private static ConstructorInfo? GetStringConstructor(Type type) =>
+            type.GetConstructor(new[] {typeof(string)});
+
+        private static MethodInfo? GetStaticParseMethod(Type type) =>
+            type.GetMethod("Parse",
+                BindingFlags.Public | BindingFlags.Static,
+                null, new[] {typeof(string)}, null);
+
+        private static MethodInfo? GetStaticParseMethodWithFormatProvider(Type type) =>
+            type.GetMethod("Parse",
+                BindingFlags.Public | BindingFlags.Static,
+                null, new[] {typeof(string), typeof(IFormatProvider)}, null);
+
+        private static object ConvertScalar(string? value, Type targetType)
+        {
+            try
+            {
+                // Primitive
+                var primitiveConverter = PrimitiveConverters.GetValueOrDefault(targetType);
+                if (primitiveConverter != null)
+                    return primitiveConverter(value);
+
+                // Enum
+                if (targetType.IsEnum)
+                    return Enum.Parse(targetType, value, true);
+
+                // Nullable
+                var nullableUnderlyingType = targetType.GetNullableUnderlyingType();
+                if (nullableUnderlyingType != null)
+                    return !string.IsNullOrWhiteSpace(value)
+                        ? ConvertScalar(value, nullableUnderlyingType)
+                        : null;
+
+                // String-constructable
+                var stringConstructor = GetStringConstructor(targetType);
+                if (stringConstructor != null)
+                    return stringConstructor.Invoke(new object[] {value});
+
+                // String-parseable (with format provider)
+                var parseMethodWithFormatProvider = GetStaticParseMethodWithFormatProvider(targetType);
+                if (parseMethodWithFormatProvider != null)
+                    return parseMethodWithFormatProvider.Invoke(null, new object[] {value, ConversionFormatProvider});
+
+                // String-parseable (without format provider)
+                var parseMethod = GetStaticParseMethod(targetType);
+                if (parseMethod != null)
+                    return parseMethod.Invoke(null, new object[] {value});
+            }
+            catch (Exception ex)
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine($"Failed to convert value '{value ?? "<null>"}' to type {targetType.FullName}.")
+                    .Append(ex.Message)
+                    .ToString(), ex);
+            }
+
+            throw new CliFxException(new StringBuilder()
+                .AppendLine($"Can't convert value '{value ?? "<null>"}' to type {targetType.FullName}.")
+                .Append("Target type is not supported by CliFx.")
+                .ToString());
+        }
+
+        private static object ConvertNonScalar(IReadOnlyList<string> values, Type targetEnumerableType, Type targetElementType)
+        {
+            var array = values
+                .Select(v => ConvertScalar(v, targetElementType))
+                .ToNonGenericArray(targetElementType);
+
+            var arrayType = array.GetType();
+
+            // Assignable from an array
+            if (targetEnumerableType.IsAssignableFrom(arrayType))
+                return array;
+
+            // Constructable from an array
+            var arrayConstructor = targetEnumerableType.GetConstructor(new[] {arrayType});
+            if (arrayConstructor != null)
+                return arrayConstructor.Invoke(new object[] {array});
+
+            throw new CliFxException(new StringBuilder()
+                .AppendLine($"Can't convert a sequence of values [{string.Join(", ", values)}] to type {targetEnumerableType.FullName}.")
+                .AppendLine($"Underlying element type is [{targetElementType.FullName}].")
+                .Append("Target type must either be assignable from an array or have a public constructor that takes a single array argument.")
+                .ToString());
+        }
+    }
+}

CliFx/Domain/CommandDirectiveInput.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace CliFx.Domain
+{
+    internal class CommandDirectiveInput
+    {
+        public string Name { get; }
+
+        public bool IsDebugDirective => string.Equals(Name, "debug", StringComparison.OrdinalIgnoreCase);
+
+        public bool IsPreviewDirective => string.Equals(Name, "preview", StringComparison.OrdinalIgnoreCase);
+
+        public CommandDirectiveInput(string name)
+        {
+            Name = name;
+        }
+
+        public override string ToString() => $"[{Name}]";
+    }
+}

CliFx/Domain/CommandLineInput.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal partial class CommandLineInput
+    {
+        public IReadOnlyList<CommandDirectiveInput> Directives { get; }
+
+        public IReadOnlyList<CommandUnboundArgumentInput> UnboundArguments { get; }
+
+        public IReadOnlyList<CommandOptionInput> Options { get; }
+
+        public bool IsDebugDirectiveSpecified => Directives.Any(d => d.IsDebugDirective);
+
+        public bool IsPreviewDirectiveSpecified => Directives.Any(d => d.IsPreviewDirective);
+
+        public bool IsHelpOptionSpecified => Options.Any(o => o.IsHelpOption);
+
+        public bool IsVersionOptionSpecified => Options.Any(o => o.IsVersionOption);
+
+        public CommandLineInput(
+            IReadOnlyList<CommandDirectiveInput> directives,
+            IReadOnlyList<CommandUnboundArgumentInput> unboundArguments,
+            IReadOnlyList<CommandOptionInput> options)
+        {
+            Directives = directives;
+            UnboundArguments = unboundArguments;
+            Options = options;
+        }
+
+        public override string ToString()
+        {
+            var buffer = new StringBuilder();
+
+            foreach (var directive in Directives)
+            {
+                buffer.AppendIfNotEmpty(' ');
+                buffer.Append(directive);
+            }
+
+            foreach (var argument in UnboundArguments)
+            {
+                buffer.AppendIfNotEmpty(' ');
+                buffer.Append(argument);
+            }
+
+            foreach (var option in Options)
+            {
+                buffer.AppendIfNotEmpty(' ');
+                buffer.Append(option);
+            }
+
+            return buffer.ToString();
+        }
+    }
+
+    internal partial class CommandLineInput
+    {
+        public static CommandLineInput Parse(IReadOnlyList<string> commandLineArguments)
+        {
+            var builder = new CommandLineInputBuilder();
+
+            var currentOptionAlias = "";
+            var currentOptionValues = new List<string>();
+
+            bool TryParseDirective(string argument)
+            {
+                if (!string.IsNullOrWhiteSpace(currentOptionAlias))
+                    return false;
+
+                if (!argument.StartsWith("[", StringComparison.OrdinalIgnoreCase) ||
+                    !argument.EndsWith("]", StringComparison.OrdinalIgnoreCase))
+                    return false;
+
+                var directive = argument.Substring(1, argument.Length - 2);
+                builder.AddDirective(directive);
+
+                return true;
+            }
+
+            bool TryParseArgument(string argument)
+            {
+                if (!string.IsNullOrWhiteSpace(currentOptionAlias))
+                    return false;
+
+                builder.AddUnboundArgument(argument);
+
+                return true;
+            }
+
+            bool TryParseOptionName(string argument)
+            {
+                if (!argument.StartsWith("--", StringComparison.OrdinalIgnoreCase))
+                    return false;
+
+                if (!string.IsNullOrWhiteSpace(currentOptionAlias))
+                    builder.AddOption(currentOptionAlias, currentOptionValues);
+
+                currentOptionAlias = argument.Substring(2);
+                currentOptionValues = new List<string>();
+
+                return true;
+            }
+
+            bool TryParseOptionShortName(string argument)
+            {
+                if (!argument.StartsWith("-", StringComparison.OrdinalIgnoreCase))
+                    return false;
+
+                foreach (var c in argument.Substring(1))
+                {
+                    if (!string.IsNullOrWhiteSpace(currentOptionAlias))
+                        builder.AddOption(currentOptionAlias, currentOptionValues);
+
+                    currentOptionAlias = c.AsString();
+                    currentOptionValues = new List<string>();
+                }
+
+                return true;
+            }
+
+            bool TryParseOptionValue(string argument)
+            {
+                if (string.IsNullOrWhiteSpace(currentOptionAlias))
+                    return false;
+
+                currentOptionValues.Add(argument);
+
+                return true;
+            }
+
+            foreach (var argument in commandLineArguments)
+            {
+                var _ =
+                    TryParseOptionName(argument) ||
+                    TryParseOptionShortName(argument) ||
+                    TryParseDirective(argument) ||
+                    TryParseArgument(argument) ||
+                    TryParseOptionValue(argument);
+            }
+
+            if (!string.IsNullOrWhiteSpace(currentOptionAlias))
+                builder.AddOption(currentOptionAlias, currentOptionValues);
+
+            return builder.Build();
+        }
+    }
+
+    internal partial class CommandLineInput
+    {
+        private static IReadOnlyList<CommandDirectiveInput> EmptyDirectives { get; } = new CommandDirectiveInput[0];
+
+        private static IReadOnlyList<CommandUnboundArgumentInput> EmptyUnboundArguments { get; } = new CommandUnboundArgumentInput[0];
+
+        private static IReadOnlyList<CommandOptionInput> EmptyOptions { get; } = new CommandOptionInput[0];
+
+        public static CommandLineInput Empty { get; } = new CommandLineInput(EmptyDirectives, EmptyUnboundArguments, EmptyOptions);
+    }
+}

CliFx/Domain/CommandLineInputBuilder.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+namespace CliFx.Domain
+{
+    internal class CommandLineInputBuilder
+    {
+        private readonly List<CommandDirectiveInput> _directives = new List<CommandDirectiveInput>();
+        private readonly List<CommandUnboundArgumentInput> _unboundArguments = new List<CommandUnboundArgumentInput>();
+        private readonly List<CommandOptionInput> _options = new List<CommandOptionInput>();
+
+        public CommandLineInputBuilder AddDirective(CommandDirectiveInput directive)
+        {
+            _directives.Add(directive);
+            return this;
+        }
+
+        public CommandLineInputBuilder AddDirective(string directive) =>
+            AddDirective(new CommandDirectiveInput(directive));
+
+        public CommandLineInputBuilder AddUnboundArgument(CommandUnboundArgumentInput unboundArgument)
+        {
+            _unboundArguments.Add(unboundArgument);
+            return this;
+        }
+
+        public CommandLineInputBuilder AddUnboundArgument(string unboundArgument) =>
+            AddUnboundArgument(new CommandUnboundArgumentInput(unboundArgument));
+
+        public CommandLineInputBuilder AddOption(CommandOptionInput option)
+        {
+            _options.Add(option);
+            return this;
+        }
+
+        public CommandLineInputBuilder AddOption(string optionAlias, IReadOnlyList<string> values) =>
+            AddOption(new CommandOptionInput(optionAlias, values));
+
+        public CommandLineInputBuilder AddOption(string optionAlias, params string[] values) =>
+            AddOption(optionAlias, (IReadOnlyList<string>) values);
+
+        public CommandLineInput Build() => new CommandLineInput(_directives, _unboundArguments, _options);
+    }
+}

CliFx/Domain/CommandOptionInput.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Text;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal class CommandOptionInput
+    {
+        public string Alias { get; }
+
+        public IReadOnlyList<string> Values { get; }
+
+        public bool IsHelpOption => CommandOptionSchema.HelpOption.MatchesNameOrShortName(Alias);
+
+        public bool IsVersionOption => CommandOptionSchema.VersionOption.MatchesNameOrShortName(Alias);
+
+        public CommandOptionInput(string alias, IReadOnlyList<string> values)
+        {
+            Alias = alias;
+            Values = values;
+        }
+
+        public override string ToString()
+        {
+            var buffer = new StringBuilder();
+
+            buffer.Append(Alias.Length > 1 ? "--" : "-");
+            buffer.Append(Alias);
+
+            foreach (var value in Values)
+            {
+                buffer.AppendIfNotEmpty(' ');
+
+                var isEscaped = value.Contains(" ");
+
+                if (isEscaped)
+                    buffer.Append('"');
+
+                buffer.Append(value);
+
+                if (isEscaped)
+                    buffer.Append('"');
+            }
+
+            return buffer.ToString();
+        }
+    }
+}

CliFx/Domain/CommandOptionSchema.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using CliFx.Attributes;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal partial class CommandOptionSchema : CommandArgumentSchema
+    {
+        public string? Name { get; }
+
+        public char? ShortName { get; }
+
+        public string DisplayName => !string.IsNullOrWhiteSpace(Name)
+            ? Name
+            : ShortName?.AsString()!;
+
+        public string? EnvironmentVariableName { get; }
+
+        public bool IsRequired { get; }
+
+        public CommandOptionSchema(
+            PropertyInfo property,
+            string? name,
+            char? shortName,
+            string? environmentVariableName,
+            bool isRequired,
+            string? description)
+            : base(property, description)
+        {
+            Name = name;
+            ShortName = shortName;
+            EnvironmentVariableName = environmentVariableName;
+            IsRequired = isRequired;
+        }
+
+        public bool MatchesName(string? name) =>
+            !string.IsNullOrWhiteSpace(Name) &&
+            string.Equals(Name, name, StringComparison.OrdinalIgnoreCase);
+
+        public bool MatchesShortName(char shortName) =>
+            ShortName != null &&
+            ShortName == shortName;
+
+        public bool MatchesNameOrShortName(string alias) =>
+            MatchesName(alias) ||
+            alias.Length == 1 && MatchesShortName(alias.Single());
+
+        public bool MatchesEnvironmentVariableName(string environmentVariableName) =>
+            !string.IsNullOrWhiteSpace(EnvironmentVariableName) &&
+            string.Equals(EnvironmentVariableName, environmentVariableName, StringComparison.OrdinalIgnoreCase);
+
+        public override string ToString()
+        {
+            var buffer = new StringBuilder();
+
+            if (!string.IsNullOrWhiteSpace(Name))
+            {
+                buffer.Append("--");
+                buffer.Append(Name);
+            }
+
+            if (!string.IsNullOrWhiteSpace(Name) && ShortName != null)
+                buffer.Append('|');
+
+            if (ShortName != null)
+            {
+                buffer.Append('-');
+                buffer.Append(ShortName);
+            }
+
+            return buffer.ToString();
+        }
+    }
+
+    internal partial class CommandOptionSchema
+    {
+        public static CommandOptionSchema? TryResolve(PropertyInfo property)
+        {
+            var attribute = property.GetCustomAttribute<CommandOptionAttribute>();
+            if (attribute == null)
+                return null;
+
+            return new CommandOptionSchema(
+                property,
+                attribute.Name,
+                attribute.ShortName,
+                attribute.EnvironmentVariableName,
+                attribute.IsRequired,
+                attribute.Description
+            );
+        }
+    }
+
+    internal partial class CommandOptionSchema
+    {
+        public static CommandOptionSchema HelpOption { get; } =
+            new CommandOptionSchema(null!, "help", 'h', null, false, "Shows help text.");
+
+        public static CommandOptionSchema VersionOption { get; } =
+            new CommandOptionSchema(null!, "version", null, null, false, "Shows version information.");
+    }
+}

CliFx/Domain/CommandParameterSchema.cs

@@ -0,0 +1,53 @@
+using System.Reflection;
+using System.Text;
+using CliFx.Attributes;
+
+namespace CliFx.Domain
+{
+    internal partial class CommandParameterSchema : CommandArgumentSchema
+    {
+        public int Order { get; }
+
+        public string? Name { get; }
+
+        public string DisplayName => !string.IsNullOrWhiteSpace(Name)
+            ? Name
+            : Property.Name.ToLowerInvariant();
+
+        public CommandParameterSchema(PropertyInfo property, int order, string? name, string? description)
+            : base(property, description)
+        {
+            Order = order;
+            Name = name;
+        }
+
+        public override string ToString()
+        {
+            var buffer = new StringBuilder();
+
+            buffer
+                .Append('<')
+                .Append(DisplayName)
+                .Append('>');
+
+            return buffer.ToString();
+        }
+    }
+
+    internal partial class CommandParameterSchema
+    {
+        public static CommandParameterSchema? TryResolve(PropertyInfo property)
+        {
+            var attribute = property.GetCustomAttribute<CommandParameterAttribute>();
+            if (attribute == null)
+                return null;
+
+            return new CommandParameterSchema(
+                property,
+                attribute.Order,
+                attribute.Name,
+                attribute.Description
+            );
+        }
+    }
+}

CliFx/Domain/CommandSchema.cs

@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using CliFx.Attributes;
+using CliFx.Exceptions;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal partial class CommandSchema
+    {
+        public Type Type { get; }
+
+        public string? Name { get; }
+
+        public bool IsDefault => string.IsNullOrWhiteSpace(Name);
+
+        public string? Description { get; }
+
+        public IReadOnlyList<CommandParameterSchema> Parameters { get; }
+
+        public IReadOnlyList<CommandOptionSchema> Options { get; }
+
+        public CommandSchema(
+            Type type,
+            string? name,
+            string? description,
+            IReadOnlyList<CommandParameterSchema> parameters,
+            IReadOnlyList<CommandOptionSchema> options)
+        {
+            Type = type;
+            Name = name;
+            Description = description;
+            Options = options;
+            Parameters = parameters;
+        }
+
+        public bool MatchesName(string? name) => string.Equals(name, Name, StringComparison.OrdinalIgnoreCase);
+
+        private void InjectParameters(ICommand command, IReadOnlyList<string> parameterInputs)
+        {
+            // All inputs must be bound
+            var remainingParameterInputs = parameterInputs.ToList();
+
+            // Scalar parameters
+            var scalarParameters = Parameters
+                .OrderBy(p => p.Order)
+                .TakeWhile(p => p.IsScalar)
+                .ToArray();
+
+            for (var i = 0; i < scalarParameters.Length; i++)
+            {
+                var scalarParameter = scalarParameters[i];
+
+                var scalarParameterInput = i < parameterInputs.Count
+                    ? parameterInputs[i]
+                    : throw new CliFxException($"Missing value for parameter <{scalarParameter.DisplayName}>.");
+
+                scalarParameter.Inject(command, scalarParameterInput);
+                remainingParameterInputs.Remove(scalarParameterInput);
+            }
+
+            // Non-scalar parameter (only one is allowed)
+            var nonScalarParameter = Parameters
+                .OrderBy(p => p.Order)
+                .FirstOrDefault(p => !p.IsScalar);
+
+            if (nonScalarParameter != null)
+            {
+                var nonScalarParameterInputs = parameterInputs.Skip(scalarParameters.Length).ToArray();
+                nonScalarParameter.Inject(command, nonScalarParameterInputs);
+                remainingParameterInputs.Clear();
+            }
+
+            // Ensure all inputs were bound
+            if (remainingParameterInputs.Any())
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine("Unrecognized parameters provided:")
+                    .AppendBulletList(remainingParameterInputs)
+                    .ToString());
+            }
+        }
+
+        private void InjectOptions(
+            ICommand command,
+            IReadOnlyList<CommandOptionInput> optionInputs,
+            IReadOnlyDictionary<string, string> environmentVariables)
+        {
+            // All inputs must be bound
+            var remainingOptionInputs = optionInputs.ToList();
+
+            // All required options must be set
+            var unsetRequiredOptions = Options.Where(o => o.IsRequired).ToList();
+
+            // Environment variables
+            foreach (var environmentVariable in environmentVariables)
+            {
+                var option = Options.FirstOrDefault(o => o.MatchesEnvironmentVariableName(environmentVariable.Key));
+
+                if (option != null)
+                {
+                    var values = option.IsScalar
+                        ? new[] {environmentVariable.Value}
+                        : environmentVariable.Value.Split(Path.PathSeparator);
+
+                    option.Inject(command, values);
+                    unsetRequiredOptions.Remove(option);
+                }
+            }
+
+            // TODO: refactor this part? I wrote this while sick
+            // Direct input
+            foreach (var option in Options)
+            {
+                var inputs = optionInputs
+                    .Where(i => option.MatchesNameOrShortName(i.Alias))
+                    .ToArray();
+
+                if (inputs.Any())
+                {
+                    option.Inject(command, inputs.SelectMany(i => i.Values).ToArray());
+
+                    foreach (var input in inputs)
+                        remainingOptionInputs.Remove(input);
+
+                    unsetRequiredOptions.Remove(option);
+                }
+            }
+
+            // Ensure all required options were set
+            if (unsetRequiredOptions.Any())
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine("Missing values for some of the required options:")
+                    .AppendBulletList(unsetRequiredOptions.Select(o => o.DisplayName))
+                    .ToString());
+            }
+
+            // Ensure all inputs were bound
+            if (remainingOptionInputs.Any())
+            {
+                throw new CliFxException(new StringBuilder()
+                    .AppendLine("Unrecognized options provided:")
+                    .AppendBulletList(remainingOptionInputs.Select(o => o.Alias).Distinct())
+                    .ToString());
+            }
+        }
+
+        public ICommand CreateInstance(
+            IReadOnlyList<string> parameterInputs,
+            IReadOnlyList<CommandOptionInput> optionInputs,
+            IReadOnlyDictionary<string, string> environmentVariables,
+            ITypeActivator activator)
+        {
+            var command = (ICommand) activator.CreateInstance(Type);
+
+            InjectParameters(command, parameterInputs);
+            InjectOptions(command, optionInputs, environmentVariables);
+
+            return command;
+        }
+
+        public override string ToString()
+        {
+            var buffer = new StringBuilder();
+
+            if (!string.IsNullOrWhiteSpace(Name))
+                buffer.Append(Name);
+
+            foreach (var parameter in Parameters)
+            {
+                buffer.AppendIfNotEmpty(' ');
+                buffer.Append(parameter);
+            }
+
+            foreach (var option in Options)
+            {
+                buffer.AppendIfNotEmpty(' ');
+                buffer.Append(option);
+            }
+
+            return buffer.ToString();
+        }
+    }
+
+    internal partial class CommandSchema
+    {
+        public static bool IsCommandType(Type type) =>
+            type.Implements(typeof(ICommand)) &&
+            type.IsDefined(typeof(CommandAttribute)) &&
+            !type.IsAbstract &&
+            !type.IsInterface;
+
+        public static CommandSchema? TryResolve(Type type)
+        {
+            if (!IsCommandType(type))
+                return null;
+
+            var attribute = type.GetCustomAttribute<CommandAttribute>();
+
+            var parameters = type.GetProperties()
+                .Select(CommandParameterSchema.TryResolve)
+                .Where(p => p != null)
+                .ToArray();
+
+            var options = type.GetProperties()
+                .Select(CommandOptionSchema.TryResolve)
+                .Where(o => o != null)
+                .ToArray();
+
+            return new CommandSchema(
+                type,
+                attribute?.Name,
+                attribute?.Description,
+                parameters,
+                options
+            );
+        }
+    }
+
+    internal partial class CommandSchema
+    {
+        public static CommandSchema StubDefaultCommand { get; } =
+            new CommandSchema(null!, null, null, new CommandParameterSchema[0], new CommandOptionSchema[0]);
+    }
+}

CliFx/Domain/CommandUnboundArgumentInput.cs

@@ -0,0 +1,14 @@
+namespace CliFx.Domain
+{
+    internal class CommandUnboundArgumentInput
+    {
+        public string Value { get; }
+
+        public CommandUnboundArgumentInput(string value)
+        {
+            Value = value;
+        }
+
+        public override string ToString() => Value;
+    }
+}

CliFx/Domain/HelpTextWriter.cs

@@ -0,0 +1,332 @@
+using System;
+using System.Linq;
+using CliFx.Internal;
+
+namespace CliFx.Domain
+{
+    internal class HelpTextWriter
+    {
+        private readonly ApplicationMetadata _metadata;
+        private readonly IConsole _console;
+
+        public HelpTextWriter(ApplicationMetadata metadata, IConsole console)
+        {
+            _metadata = metadata;
+            _console = console;
+        }
+
+        public void Write(ApplicationSchema applicationSchema, CommandSchema command)
+        {
+            var column = 0;
+            var row = 0;
+
+            var childCommands = applicationSchema.GetChildCommands(command.Name);
+
+            bool IsEmpty() => column == 0 && row == 0;
+
+            void Render(string text)
+            {
+                _console.Output.Write(text);
+
+                column += text.Length;
+            }
+
+            void RenderNewLine()
+            {
+                _console.Output.WriteLine();
+
+                column = 0;
+                row++;
+            }
+
+            void RenderMargin(int lines = 1)
+            {
+                if (!IsEmpty())
+                {
+                    for (var i = 0; i < lines; i++)
+                        RenderNewLine();
+                }
+            }
+
+            void RenderIndent(int spaces = 2)
+            {
+                Render(' '.Repeat(spaces));
+            }
+
+            void RenderColumnIndent(int spaces = 20, int margin = 2)
+            {
+                if (column + margin < spaces)
+                {
+                    RenderIndent(spaces - column);
+                }
+                else
+                {
+                    Render(" ");
+                }
+            }
+
+            void RenderWithColor(string text, ConsoleColor foregroundColor)
+            {
+                _console.WithForegroundColor(foregroundColor, () => Render(text));
+            }
+
+            void RenderHeader(string text)
+            {
+                RenderWithColor(text, ConsoleColor.Magenta);
+                RenderNewLine();
+            }
+
+            void RenderApplicationInfo()
+            {
+                if (!command.IsDefault)
+                    return;
+
+                // Title and version
+                RenderWithColor(_metadata.Title, ConsoleColor.Yellow);
+                Render(" ");
+                RenderWithColor(_metadata.VersionText, ConsoleColor.Yellow);
+                RenderNewLine();
+
+                // Description
+                if (!string.IsNullOrWhiteSpace(_metadata.Description))
+                {
+                    Render(_metadata.Description);
+                    RenderNewLine();
+                }
+            }
+
+            void RenderDescription()
+            {
+                if (string.IsNullOrWhiteSpace(command.Description))
+                    return;
+
+                RenderMargin();
+                RenderHeader("Description");
+
+                RenderIndent();
+                Render(command.Description);
+                RenderNewLine();
+            }
+
+            void RenderUsage()
+            {
+                RenderMargin();
+                RenderHeader("Usage");
+
+                // Exe name
+                RenderIndent();
+                Render(_metadata.ExecutableName);
+
+                // Command name
+                if (!string.IsNullOrWhiteSpace(command.Name))
+                {
+                    Render(" ");
+                    RenderWithColor(command.Name, ConsoleColor.Cyan);
+                }
+
+                // Child command placeholder
+                if (childCommands.Any())
+                {
+                    Render(" ");
+                    RenderWithColor("[command]", ConsoleColor.Cyan);
+                }
+
+                // Parameters
+                foreach (var parameter in command.Parameters)
+                {
+                    Render(" ");
+                    Render(parameter.IsScalar
+                        ? $"<{parameter.DisplayName}>"
+                        : $"<{parameter.DisplayName}...>");
+                }
+
+                // Required options
+                var requiredOptionSchemas = command.Options
+                    .Where(o => o.IsRequired)
+                    .ToArray();
+
+                foreach (var option in requiredOptionSchemas)
+                {
+                    Render(" ");
+                    if (!string.IsNullOrWhiteSpace(option.Name))
+                    {
+                        RenderWithColor($"--{option.Name}", ConsoleColor.White);
+                        Render(" ");
+                        Render(option.IsScalar
+                            ? "<value>"
+                            : "<values...>");
+                    }
+                    else
+                    {
+                        RenderWithColor($"-{option.ShortName}", ConsoleColor.White);
+                        Render(" ");
+                        Render(option.IsScalar
+                            ? "<value>"
+                            : "<values...>");
+                    }
+                }
+
+                // Options placeholder
+                if (command.Options.Count != requiredOptionSchemas.Length)
+                {
+                    Render(" ");
+                    RenderWithColor("[options]", ConsoleColor.White);
+                }
+
+                RenderNewLine();
+            }
+
+            void RenderParameters()
+            {
+                if (!command.Parameters.Any())
+                    return;
+
+                RenderMargin();
+                RenderHeader("Parameters");
+
+                var parameters = command.Parameters
+                    .OrderBy(p => p.Order)
+                    .ToArray();
+
+                foreach (var parameter in parameters)
+                {
+                    RenderWithColor("* ", ConsoleColor.Red);
+                    RenderWithColor($"{parameter.DisplayName}", ConsoleColor.White);
+
+                    RenderColumnIndent();
+
+                    // Description
+                    if (!string.IsNullOrWhiteSpace(parameter.Description))
+                    {
+                        Render(parameter.Description);
+                    }
+
+                    RenderNewLine();
+                }
+            }
+
+            void RenderOptions()
+            {
+                RenderMargin();
+                RenderHeader("Options");
+
+                var options = command.Options
+                    .OrderByDescending(o => o.IsRequired)
+                    .ToList();
+
+                // Add built-in options
+                options.Add(CommandOptionSchema.HelpOption);
+                if (command.IsDefault)
+                    options.Add(CommandOptionSchema.VersionOption);
+
+                foreach (var option in options)
+                {
+                    if (option.IsRequired)
+                    {
+                        RenderWithColor("* ", ConsoleColor.Red);
+                    }
+                    else
+                    {
+                        RenderIndent();
+                    }
+
+                    // Short name
+                    if (option.ShortName != null)
+                    {
+                        RenderWithColor($"-{option.ShortName}", ConsoleColor.White);
+                    }
+
+                    // Delimiter
+                    if (!string.IsNullOrWhiteSpace(option.Name) && option.ShortName != null)
+                    {
+                        Render("|");
+                    }
+
+                    // Name
+                    if (!string.IsNullOrWhiteSpace(option.Name))
+                    {
+                        RenderWithColor($"--{option.Name}", ConsoleColor.White);
+                    }
+
+                    RenderColumnIndent();
+
+                    // Description
+                    if (!string.IsNullOrWhiteSpace(option.Description))
+                    {
+                        Render(option.Description);
+                        Render(" ");
+                    }
+
+                    // Environment variable
+                    if (!string.IsNullOrWhiteSpace(option.EnvironmentVariableName))
+                    {
+                        Render($"(Environment variable: {option.EnvironmentVariableName}).");
+                        Render(" ");
+                    }
+
+                    RenderNewLine();
+                }
+            }
+
+            void RenderChildCommands()
+            {
+                if (!childCommands.Any())
+                    return;
+
+                RenderMargin();
+                RenderHeader("Commands");
+
+                foreach (var childCommand in childCommands)
+                {
+                    var relativeCommandName =
+                        string.IsNullOrWhiteSpace(childCommand.Name) || string.IsNullOrWhiteSpace(command.Name)
+                            ? childCommand.Name
+                            : childCommand.Name.Substring(command.Name.Length + 1);
+
+                    // Name
+                    RenderIndent();
+                    RenderWithColor(relativeCommandName, ConsoleColor.Cyan);
+
+                    // Description
+                    if (!string.IsNullOrWhiteSpace(childCommand.Description))
+                    {
+                        RenderColumnIndent();
+                        Render(childCommand.Description);
+                    }
+
+                    RenderNewLine();
+                }
+
+                RenderMargin();
+
+                // Child command help tip
+                Render("You can run `");
+                Render(_metadata.ExecutableName);
+
+                if (!string.IsNullOrWhiteSpace(command.Name))
+                {
+                    Render(" ");
+                    RenderWithColor(command.Name, ConsoleColor.Cyan);
+                }
+
+                Render(" ");
+                RenderWithColor("[command]", ConsoleColor.Cyan);
+
+                Render(" ");
+                RenderWithColor("--help", ConsoleColor.White);
+
+                Render("` to show help on a specific command.");
+
+                RenderNewLine();
+            }
+
+            _console.ResetColor();
+            RenderApplicationInfo();
+            RenderDescription();
+            RenderUsage();
+            RenderParameters();
+            RenderOptions();
+            RenderChildCommands();
+        }
+    }
+}

CliFx/Exceptions/CliFxException.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace CliFx.Exceptions
+{
+    /// <summary>
+    /// Domain exception thrown within CliFx.
+    /// </summary>
+    public class CliFxException : Exception
+    {
+        /// <summary>
+        /// Initializes an instance of <see cref="CliFxException"/>.
+        /// </summary>
+        public CliFxException(string? message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CliFxException"/>.
+        /// </summary>
+        public CliFxException(string? message, Exception? innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

CliFx/Exceptions/CommandException.cs

@@ -0,0 +1,46 @@
+using System;
+
+namespace CliFx.Exceptions
+{
+    /// <summary>
+    /// Thrown when a command cannot proceed with normal execution due to an error.
+    /// Use this exception if you want to report an error that occured during execution of a command.
+    /// This exception also allows specifying exit code which will be returned to the calling process.
+    /// </summary>
+    public class CommandException : Exception
+    {
+        private const int DefaultExitCode = -100;
+
+        /// <summary>
+        /// Process exit code.
+        /// </summary>
+        public int ExitCode { get; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandException"/>.
+        /// </summary>
+        public CommandException(string? message, Exception? innerException, int exitCode = DefaultExitCode)
+            : base(message, innerException)
+        {
+            ExitCode = exitCode != 0
+                ? exitCode
+                : throw new ArgumentException("Exit code must not be zero in order to signify failure.");
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandException"/>.
+        /// </summary>
+        public CommandException(string? message, int exitCode = DefaultExitCode)
+            : this(message, null, exitCode)
+        {
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="CommandException"/>.
+        /// </summary>
+        public CommandException(int exitCode = DefaultExitCode)
+            : this(null, exitCode)
+        {
+        }
+    }
+}

CliFx/Exceptions/CommandResolveException.cs

@@ -1,21 +0,0 @@
-using System;
-
-namespace CliFx.Exceptions
-{
-    public class CommandResolveException : Exception
-    {
-        public CommandResolveException()
-        {
-        }
-
-        public CommandResolveException(string message)
-            : base(message)
-        {
-        }
-
-        public CommandResolveException(string message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
-    }
-}

CliFx/Extensions.cs

@@ -1,12 +1,42 @@
 using System;
-using System.Linq;
-using System.Threading.Tasks;
 
 namespace CliFx
 {
+    /// <summary>
+    /// Extensions for <see cref="CliFx"/>
+    /// </summary>
     public static class Extensions
     {
-        public static Task<int> RunAsync(this ICliApplication application) =>
+        /// <summary>
-            application.RunAsync(Environment.GetCommandLineArgs().Skip(1).ToArray());
+        /// Sets console foreground color, executes specified action, and sets the color back to the original value.
+        /// </summary>
+        public static void WithForegroundColor(this IConsole console, ConsoleColor foregroundColor, Action action)
+        {
+            var lastColor = console.ForegroundColor;
+            console.ForegroundColor = foregroundColor;
+
+            action();
+
+            console.ForegroundColor = lastColor;
+        }
+
+        /// <summary>
+        /// Sets console background color, executes specified action, and sets the color back to the original value.
+        /// </summary>
+        public static void WithBackgroundColor(this IConsole console, ConsoleColor backgroundColor, Action action)
+        {
+            var lastColor = console.BackgroundColor;
+            console.BackgroundColor = backgroundColor;
+
+            action();
+
+            console.BackgroundColor = lastColor;
+        }
+
+        /// <summary>
+        /// Sets console foreground and background colors, executes specified action, and sets the colors back to the original values.
+        /// </summary>
+        public static void WithColors(this IConsole console, ConsoleColor foregroundColor, ConsoleColor backgroundColor, Action action) =>
+            console.WithForegroundColor(foregroundColor, () => console.WithBackgroundColor(backgroundColor, action));
     }
 }

CliFx/ICliApplication.cs

@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace CliFx
-{
-    public interface ICliApplication
-    {
-        Task<int> RunAsync(IReadOnlyList<string> commandLineArguments);
-    }
-}

CliFx/ICommand.cs

@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Entry point in a command line application.
+    /// </summary>
+    public interface ICommand
+    {
+        /// <summary>
+        /// Executes the command using the specified implementation of <see cref="IConsole"/>.
+        /// This is the method that's called when the command is invoked by a user through command line interface.
+        /// </summary>
+        /// <remarks>If the execution of the command is not asynchronous, simply end the method with <code>return default;</code></remarks>
+        ValueTask ExecuteAsync(IConsole console);
+    }
+}

CliFx/IConsole.cs

@@ -0,0 +1,64 @@
+using System;
+using System.IO;
+using System.Threading;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Abstraction for interacting with the console.
+    /// </summary>
+    public interface IConsole
+    {
+        /// <summary>
+        /// Input stream (stdin).
+        /// </summary>
+        StreamReader Input { get; }
+
+        /// <summary>
+        /// Whether the input stream is redirected.
+        /// </summary>
+        bool IsInputRedirected { get; }
+
+        /// <summary>
+        /// Output stream (stdout).
+        /// </summary>
+        StreamWriter Output { get; }
+
+        /// <summary>
+        /// Whether the output stream is redirected.
+        /// </summary>
+        bool IsOutputRedirected { get; }
+
+        /// <summary>
+        /// Error stream (stderr).
+        /// </summary>
+        StreamWriter Error { get; }
+
+        /// <summary>
+        /// Whether the error stream is redirected.
+        /// </summary>
+        bool IsErrorRedirected { get; }
+
+        /// <summary>
+        /// Current foreground color.
+        /// </summary>
+        ConsoleColor ForegroundColor { get; set; }
+
+        /// <summary>
+        /// Current background color.
+        /// </summary>
+        ConsoleColor BackgroundColor { get; set; }
+
+        /// <summary>
+        /// Resets foreground and background color to default values.
+        /// </summary>
+        void ResetColor();
+
+        /// <summary>
+        /// Provides a token that signals when application cancellation is requested.
+        /// Subsequent calls return the same token.
+        /// When working with system console, the user can request cancellation by issuing an interrupt signal (Ctrl+C).
+        /// </summary>
+        CancellationToken GetCancellationToken();
+    }
+}

CliFx/ITypeActivator.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace CliFx
+{
+    /// <summary>
+    /// Abstraction for a service can initialize objects at runtime.
+    /// </summary>
+    public interface ITypeActivator
+    {
+        /// <summary>
+        /// Creates an instance of specified type.
+        /// </summary>
+        object CreateInstance(Type type);
+    }
+}

CliFx/Internal/CommandOptionProperty.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Reflection;
-using CliFx.Attributes;
-
-namespace CliFx.Internal
-{
-    internal partial class CommandOptionProperty
-    {
-        private readonly PropertyInfo _property;
-
-        public Type Type => _property.PropertyType;
-
-        public string Name { get; }
-
-        public char ShortName { get; }
-
-        public bool IsRequired { get; }
-
-        public string Description { get; }
-
-        public CommandOptionProperty(PropertyInfo property, string name, char shortName, bool isRequired, string description)
-        {
-            _property = property;
-            Name = name;
-            ShortName = shortName;
-            IsRequired = isRequired;
-            Description = description;
-        }
-
-        public void SetValue(Command command, object value) => _property.SetValue(command, value);
-    }
-
-    internal partial class CommandOptionProperty
-    {
-        public static bool IsValid(PropertyInfo property) => property.IsDefined(typeof(CommandOptionAttribute));
-
-        public static CommandOptionProperty Initialize(PropertyInfo property)
-        {
-            if (!IsValid(property))
-                throw new InvalidOperationException($"[{property.Name}] is not a valid command option property.");
-
-            var attribute = property.GetCustomAttribute<CommandOptionAttribute>();
-
-            return new CommandOptionProperty(property, attribute.Name, attribute.ShortName, attribute.IsRequired,
-                attribute.Description);
-        }
-    }
-}