Initial commits

examples/Cli/Delegates/BarSettings.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel;
+using Spectre.Console.Cli;
+
+namespace Delegates;
+
+public static partial class Program
+{
+    public sealed class BarSettings : CommandSettings
+    {
+        [CommandOption("--count")]
+        [Description("The number of bars to print")]
+        [DefaultValue(3)]
+        public int Count { get; set; }
+    }
+}

examples/Cli/Delegates/Delegates.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <ExampleName>Delegates</ExampleName>
+    <ExampleDescription>Demonstrates how to specify commands as delegates.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Delegates/Program.cs

@@ -0,0 +1,61 @@
+using System.Threading.Tasks;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace Delegates;
+
+public static partial class Program
+{
+    public static int Main(string[] args)
+    {
+        var app = new CommandApp();
+        app.Configure(config =>
+        {
+            config.AddDelegate("foo", Foo)
+                .WithDescription("Foos the bars");
+
+            config.AddDelegate<BarSettings>("bar", Bar)
+                .WithDescription("Bars the foos");
+
+            config.AddAsyncDelegate("fooAsync", FooAsync)
+                .WithDescription("Foos the bars asynchronously");
+
+            config.AddAsyncDelegate<BarSettings>("barAsync", BarAsync)
+                .WithDescription("Bars the foos asynchronously");
+        });
+
+        return app.Run(args);
+    }
+
+    private static int Foo(CommandContext context)
+    {
+        AnsiConsole.WriteLine("Foo");
+        return 0;
+    }
+
+    private static int Bar(CommandContext context, BarSettings settings)
+    {
+        for (var index = 0; index < settings.Count; index++)
+        {
+            AnsiConsole.WriteLine("Bar");
+        }
+
+        return 0;
+    }
+
+    private static Task<int> FooAsync(CommandContext context)
+    {
+        AnsiConsole.WriteLine("Foo");
+        return Task.FromResult(0);
+    }
+
+    private static Task<int> BarAsync(CommandContext context, BarSettings settings)
+    {
+        for (var index = 0; index < settings.Count; index++)
+        {
+            AnsiConsole.WriteLine("Bar");
+        }
+
+        return Task.FromResult(0);
+    }
+}

examples/Cli/Demo/Commands/Add/AddPackageCommand.cs

@@ -0,0 +1,46 @@
+using System.ComponentModel;
+using Demo.Utilities;
+using Spectre.Console.Cli;
+
+namespace Demo.Commands.Add;
+
+[Description("Add a NuGet package reference to the project.")]
+public sealed class AddPackageCommand : Command<AddPackageCommand.Settings>
+{
+    public sealed class Settings : AddSettings
+    {
+        [CommandArgument(0, "<PACKAGENAME>")]
+        [Description("The package reference to add.")]
+        public string PackageName { get; set; }
+
+        [CommandOption("-v|--version <VERSION>")]
+        [Description("The version of the package to add.")]
+        public string Version { get; set; }
+
+        [CommandOption("-f|--framework <FRAMEWORK>")]
+        [Description("Add the reference only when targeting a specific framework.")]
+        public string Framework { get; set; }
+
+        [CommandOption("--no-restore")]
+        [Description("Add the reference without performing restore preview and compatibility check.")]
+        public bool NoRestore { get; set; }
+
+        [CommandOption("--source <SOURCE>")]
+        [Description("The NuGet package source to use during the restore.")]
+        public string Source { get; set; }
+
+        [CommandOption("--package-directory <PACKAGEDIR>")]
+        [Description("The directory to restore packages to.")]
+        public string PackageDirectory { get; set; }
+
+        [CommandOption("--interactive")]
+        [Description("Allows the command to stop and wait for user input or action (for example to complete authentication).")]
+        public bool Interactive { get; set; }
+    }
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        SettingsDumper.Dump(settings);
+        return 0;
+    }
+}

examples/Cli/Demo/Commands/Add/AddReferenceCommand.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel;
+using Demo.Utilities;
+using Spectre.Console.Cli;
+
+namespace Demo.Commands.Add;
+
+public sealed class AddReferenceCommand : Command<AddReferenceCommand.Settings>
+{
+    public sealed class Settings : AddSettings
+    {
+        [CommandArgument(0, "<PROJECTPATH>")]
+        [Description("The package reference to add.")]
+        public string ProjectPath { get; set; }
+
+        [CommandOption("-f|--framework <FRAMEWORK>")]
+        [Description("Add the reference only when targeting a specific framework.")]
+        public string Framework { get; set; }
+
+        [CommandOption("--interactive")]
+        [Description("Allows the command to stop and wait for user input or action (for example to complete authentication).")]
+        public bool Interactive { get; set; }
+    }
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        SettingsDumper.Dump(settings);
+        return 0;
+    }
+}

examples/Cli/Demo/Commands/Add/AddSettings.cs

@@ -0,0 +1,11 @@
+using System.ComponentModel;
+using Spectre.Console.Cli;
+
+namespace Demo.Commands.Add;
+
+public abstract class AddSettings : CommandSettings
+{
+    [CommandArgument(0, "<PROJECT>")]
+    [Description("The project file to operate on. If a file is not specified, the command will search the current directory for one.")]
+    public string Project { get; set; }
+}

examples/Cli/Demo/Commands/Run/RunCommand.cs

@@ -0,0 +1,69 @@
+using System.ComponentModel;
+using Demo.Utilities;
+using Spectre.Console.Cli;
+
+namespace Demo.Commands.Run;
+
+[Description("Build and run a .NET project output.")]
+public sealed class RunCommand : Command<RunCommand.Settings>
+{
+    public sealed class Settings : CommandSettings
+    {
+        [CommandOption("-c|--configuration <CONFIGURATION>")]
+        [Description("The configuration to run for. The default for most projects is '[grey]Debug[/]'.")]
+        [DefaultValue("Debug")]
+        public string Configuration { get; set; }
+
+        [CommandOption("-f|--framework <FRAMEWORK>")]
+        [Description("The target framework to run for. The target framework must also be specified in the project file.")]
+        public string Framework { get; set; }
+
+        [CommandOption("-r|--runtime <RUNTIMEIDENTIFIER>")]
+        [Description("The target runtime to run for.")]
+        public string RuntimeIdentifier { get; set; }
+
+        [CommandOption("-p|--project <PROJECTPATH>")]
+        [Description("The path to the project file to run (defaults to the current directory if there is only one project).")]
+        public string ProjectPath { get; set; }
+
+        [CommandOption("--launch-profile <LAUNCHPROFILE>")]
+        [Description("The name of the launch profile (if any) to use when launching the application.")]
+        public string LaunchProfile { get; set; }
+
+        [CommandOption("--no-launch-profile")]
+        [Description("Do not attempt to use [grey]launchSettings.json[/] to configure the application.")]
+        public bool NoLaunchProfile { get; set; }
+
+        [CommandOption("--no-build")]
+        [Description("Do not build the project before running. Implies [grey]--no-restore[/].")]
+        public bool NoBuild { get; set; }
+
+        [CommandOption("--interactive")]
+        [Description("Allows the command to stop and wait for user input or action (for example to complete authentication).")]
+        public string Interactive { get; set; }
+
+        [CommandOption("--no-restore")]
+        [Description("Do not restore the project before building.")]
+        public bool NoRestore { get; set; }
+
+        [CommandOption("--verbosity <VERBOSITY>")]
+        [Description("Set the MSBuild verbosity level. Allowed values are q[grey]uiet[/], m[grey]inimal[/], n[grey]ormal[/], d[grey]etailed[/], and diag[grey]nostic[/].")]
+        [TypeConverter(typeof(VerbosityConverter))]
+        [DefaultValue(Verbosity.Normal)]
+        public Verbosity Verbosity { get; set; }
+
+        [CommandOption("--no-dependencies")]
+        [Description("Do not restore project-to-project references and only restore the specified project.")]
+        public bool NoDependencies { get; set; }
+
+        [CommandOption("--force")]
+        [Description("Force all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting [grey]project.assets.json[/].")]
+        public bool Force { get; set; }
+    }
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        SettingsDumper.Dump(settings);
+        return 0;
+    }
+}

examples/Cli/Demo/Commands/Serve/ServeCommand.cs

@@ -0,0 +1,40 @@
+using System;
+using System.ComponentModel;
+using Demo.Utilities;
+using Spectre.Console.Cli;
+
+namespace Demo.Commands.Serve;
+
+[Description("Launches a web server in the current working directory and serves all files in it.")]
+public sealed class ServeCommand : Command<ServeCommand.Settings>
+{
+    public sealed class Settings : CommandSettings
+    {
+        [CommandOption("-p|--port <PORT>")]
+        [Description("Port to use. Defaults to [grey]8080[/]. Use [grey]0[/] for a dynamic port.")]
+        public int Port { get; set; }
+
+        [CommandOption("-o|--open-browser [BROWSER]")]
+        [Description("Open a web browser when the server starts. You can also specify which browser to use. If none is specified, the default one will be used.")]
+        public FlagValue<string> OpenBrowser { get; set; }
+    }
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        if (settings.OpenBrowser.IsSet)
+        {
+            var browser = settings.OpenBrowser.Value;
+            if (browser != null)
+            {
+                Console.WriteLine($"Open in {browser}");
+            }
+            else
+            {
+                Console.WriteLine($"Open in default browser.");
+            }
+        }
+
+        SettingsDumper.Dump(settings);
+        return 0;
+    }
+}

examples/Cli/Demo/Demo.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <ExampleName>Demo</ExampleName>
+    <ExampleDescription>Demonstrates the most common use cases of Spectre.Cli.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Demo/Program.cs

@@ -0,0 +1,39 @@
+using Demo.Commands;
+using Demo.Commands.Add;
+using Demo.Commands.Run;
+using Demo.Commands.Serve;
+using Spectre.Console.Cli;
+
+namespace Demo;
+
+public static class Program
+{
+    public static int Main(string[] args)
+    {
+        var app = new CommandApp();
+        app.Configure(config =>
+        {
+            config.SetApplicationName("fake-dotnet");
+            config.ValidateExamples();
+            config.AddExample("run", "--no-build");
+
+            // Run
+            config.AddCommand<RunCommand>("run");
+
+            // Add
+            config.AddBranch<AddSettings>("add", add =>
+            {
+                add.SetDescription("Add a package or reference to a .NET project");
+                add.AddCommand<AddPackageCommand>("package");
+                add.AddCommand<AddReferenceCommand>("reference");
+            });
+
+            // Serve
+            config.AddCommand<ServeCommand>("serve")
+                .WithExample("serve", "-o", "firefox")
+                .WithExample("serve", "--port", "80", "-o", "firefox");
+            });
+
+        return app.Run(args);
+    }
+}

examples/Cli/Demo/Utilities/SettingsDumper.cs

@@ -0,0 +1,28 @@
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace Demo.Utilities;
+
+public static class SettingsDumper
+{
+    public static void Dump(CommandSettings settings)
+    {
+        var table = new Table().RoundedBorder();
+        table.AddColumn("[grey]Name[/]");
+        table.AddColumn("[grey]Value[/]");
+
+        var properties = settings.GetType().GetProperties();
+        foreach (var property in properties)
+        {
+            var value = property.GetValue(settings)
+                ?.ToString()
+                ?.Replace("[", "[[");
+
+            table.AddRow(
+                property.Name,
+                value ?? "[grey]null[/]");
+        }
+
+        AnsiConsole.Write(table);
+    }
+}

examples/Cli/Demo/Verbosity.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace Demo;
+
+public enum Verbosity
+{
+    Quiet,
+    Minimal,
+    Normal,
+    Detailed,
+    Diagnostic
+}
+
+public sealed class VerbosityConverter : TypeConverter
+{
+    private readonly Dictionary<string, Verbosity> _lookup;
+
+    public VerbosityConverter()
+    {
+        _lookup = new Dictionary<string, Verbosity>(StringComparer.OrdinalIgnoreCase)
+            {
+                { "q", Verbosity.Quiet },
+                { "quiet", Verbosity.Quiet },
+                { "m", Verbosity.Minimal },
+                { "minimal", Verbosity.Minimal },
+                { "n", Verbosity.Normal },
+                { "normal", Verbosity.Normal },
+                { "d", Verbosity.Detailed },
+                { "detailed", Verbosity.Detailed },
+                { "diag", Verbosity.Diagnostic },
+                { "diagnostic", Verbosity.Diagnostic }
+            };
+    }
+
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+    {
+        if (value is string stringValue)
+        {
+            var result = _lookup.TryGetValue(stringValue, out var verbosity);
+            if (!result)
+            {
+                const string format = "The value '{0}' is not a valid verbosity.";
+                var message = string.Format(CultureInfo.InvariantCulture, format, value);
+                throw new InvalidOperationException(message);
+            }
+            return verbosity;
+        }
+        throw new NotSupportedException("Can't convert value to verbosity.");
+    }
+}

examples/Cli/Dynamic/Dynamic.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <ExampleName>Dynamic</ExampleName>
+    <ExampleDescription>Demonstrates how to define dynamic commands.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Dynamic/MyCommand.cs

@@ -0,0 +1,20 @@
+using System;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace Dynamic;
+
+public sealed class MyCommand : Command
+{
+    public override int Execute(CommandContext context)
+    {
+        if (!(context.Data is int data))
+        {
+            throw new InvalidOperationException("Command has no associated data.");
+
+        }
+
+        AnsiConsole.WriteLine("Value = {0}", data);
+        return 0;
+    }
+}

examples/Cli/Dynamic/Program.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using Spectre.Console.Cli;
+
+namespace Dynamic;
+
+public static class Program
+{
+    public static int Main(string[] args)
+    {
+        var app = new CommandApp();
+        app.Configure(config =>
+        {
+            foreach (var index in Enumerable.Range(1, 10))
+            {
+                config.AddCommand<MyCommand>($"c{index}")
+                    .WithDescription($"Prints the number {index}")
+                    .WithData(index);
+            }
+        });
+
+        return app.Run(args);
+    }
+}

examples/Cli/Help/CustomHelpProvider.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+using Spectre.Console;
+using Spectre.Console.Cli;
+using Spectre.Console.Cli.Help;
+using Spectre.Console.Rendering;
+
+namespace Help;
+
+/// <summary>
+/// Example showing how to extend the built-in Spectre.Console help provider
+/// by rendering a custom banner at the top of the help information
+/// </summary>
+internal class CustomHelpProvider : HelpProvider
+{
+    public CustomHelpProvider(ICommandAppSettings settings)
+        : base(settings)
+    {
+    }
+
+    public override IEnumerable<IRenderable> GetHeader(ICommandModel model, ICommandInfo? command)
+    {
+        return new[]
+        {
+            new Text("--------------------------------------"), Text.NewLine,
+            new Text("---      CUSTOM HELP PROVIDER      ---"), Text.NewLine,
+            new Text("--------------------------------------"), Text.NewLine,
+            Text.NewLine,
+        };
+    }
+}

examples/Cli/Help/DefaultCommand.cs

@@ -0,0 +1,20 @@
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace Help;
+
+public sealed class DefaultCommand : Command
+{
+    private IAnsiConsole _console;
+
+    public DefaultCommand(IAnsiConsole console)
+    {
+        _console = console;
+    }
+
+    public override int Execute(CommandContext context)
+    {
+        _console.WriteLine("Hello world");
+        return 0;
+    }
+}

examples/Cli/Help/Help.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <ExampleName>Help</ExampleName>
+    <ExampleDescription>Demonstrates how to extend the built-in Spectre.Console help provider to render a custom banner at the top of the help information.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Help/Program.cs

@@ -0,0 +1,23 @@
+using Spectre.Console.Cli;
+using Spectre.Console.Cli.Help;
+
+namespace Help;
+
+public static class Program
+{
+    public static int Main(string[] args)
+    {
+        var app = new CommandApp<DefaultCommand>();
+
+        app.Configure(config =>
+        {
+            // Register the custom help provider
+            config.SetHelpProvider(new CustomHelpProvider(config.Settings));
+
+            // Render an unstyled help text for maximum accessibility
+            config.Settings.HelpProviderStyles = null;
+        });
+
+        return app.Run(args);
+    }
+}

examples/Cli/Injection/Commands/DefaultCommand.cs

@@ -0,0 +1,29 @@
+using System;
+using System.ComponentModel;
+using Spectre.Console.Cli;
+
+namespace Injection.Commands;
+
+public sealed class DefaultCommand : Command<DefaultCommand.Settings>
+{
+    private readonly IGreeter _greeter;
+
+    public sealed class Settings : CommandSettings
+    {
+        [CommandOption("-n|--name <NAME>")]
+        [Description("The person or thing to greet.")]
+        [DefaultValue("World")]
+        public string Name { get; set; }
+    }
+
+    public DefaultCommand(IGreeter greeter)
+    {
+        _greeter = greeter ?? throw new ArgumentNullException(nameof(greeter));
+    }
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        _greeter.Greet(settings.Name);
+        return 0;
+    }
+}

examples/Cli/Injection/IGreeter.cs

@@ -0,0 +1,16 @@
+using Spectre.Console;
+
+namespace Injection;
+
+public interface IGreeter
+{
+    void Greet(string name);
+}
+
+public sealed class HelloWorldGreeter : IGreeter
+{
+    public void Greet(string name)
+    {
+        AnsiConsole.WriteLine($"Hello {name}!");
+    }
+}

examples/Cli/Injection/Infrastructure/TypeRegistrar.cs

@@ -0,0 +1,40 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Spectre.Console.Cli;
+
+namespace Injection.Infrastructure;
+
+public sealed class TypeRegistrar : ITypeRegistrar
+{
+    private readonly IServiceCollection _builder;
+
+    public TypeRegistrar(IServiceCollection builder)
+    {
+        _builder = builder;
+    }
+
+    public ITypeResolver Build()
+    {
+        return new TypeResolver(_builder.BuildServiceProvider());
+    }
+
+    public void Register(Type service, Type implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterInstance(Type service, object implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterLazy(Type service, Func<object> func)
+    {
+        if (func is null)
+        {
+            throw new ArgumentNullException(nameof(func));
+        }
+
+        _builder.AddSingleton(service, (provider) => func());
+    }
+}

examples/Cli/Injection/Infrastructure/TypeResolver.cs

@@ -0,0 +1,32 @@
+using System;
+using Spectre.Console.Cli;
+
+namespace Injection.Infrastructure;
+
+public sealed class TypeResolver : ITypeResolver, IDisposable
+{
+    private readonly IServiceProvider _provider;
+
+    public TypeResolver(IServiceProvider provider)
+    {
+        _provider = provider ?? throw new ArgumentNullException(nameof(provider));
+    }
+
+    public object Resolve(Type type)
+    {
+        if (type == null)
+        {
+            return null;
+        }
+
+        return _provider.GetService(type);
+    }
+
+    public void Dispose()
+    {
+        if (_provider is IDisposable disposable)
+        {
+            disposable.Dispose();
+        }
+    }
+}

examples/Cli/Injection/Injection.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <ExampleName>Injection</ExampleName>
+    <ExampleDescription>Demonstrates how to use dependency injection with Spectre.Cli.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Injection/Program.cs

@@ -0,0 +1,23 @@
+using Injection.Commands;
+using Injection.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+using Spectre.Console.Cli;
+
+namespace Injection;
+
+public class Program
+{
+    public static int Main(string[] args)
+    {
+        // Create a type registrar and register any dependencies.
+        // A type registrar is an adapter for a DI framework.
+        var registrations = new ServiceCollection();
+        registrations.AddSingleton<IGreeter, HelloWorldGreeter>();
+        var registrar = new TypeRegistrar(registrations);
+
+        // Create a new command app with the registrar
+        // and run it with the provided arguments.
+        var app = new CommandApp<DefaultCommand>(registrar);
+        return app.Run(args);
+    }
+}

examples/Cli/Logging/Commands/HelloCommand.cs

@@ -0,0 +1,34 @@
+using Microsoft.Extensions.Logging;
+using Spectre.Console;
+using Spectre.Console.Cli;
+
+namespace Logging.Commands;
+
+public class HelloCommand : Command<HelloCommand.Settings>
+{
+    private ILogger<HelloCommand> _logger;
+    private IAnsiConsole _console;
+
+    public HelloCommand(IAnsiConsole console, ILogger<HelloCommand> logger)
+    {
+        _console = console;
+        _logger = logger;
+        _logger.LogDebug("{0} initialized", nameof(HelloCommand));
+    }
+
+    public class Settings : LogCommandSettings
+    {
+        [CommandArgument(0, "[Name]")]
+        public string Name { get; set; }
+    }
+
+
+    public override int Execute(CommandContext context, Settings settings)
+    {
+        _logger.LogInformation("Starting my command");
+        AnsiConsole.MarkupLine($"Hello, [blue]{settings.Name}[/]");
+        _logger.LogInformation("Completed my command");
+
+        return 0;
+    }
+}

examples/Cli/Logging/Commands/LogCommandSettings.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using Serilog.Events;
+using Spectre.Console.Cli;
+
+namespace Logging.Commands;
+
+public class LogCommandSettings : CommandSettings
+{
+    [CommandOption("--logFile")]
+    [Description("Path and file name for logging")]
+    public string LogFile { get; set; }
+
+    [CommandOption("--logLevel")]
+    [Description("Minimum level for logging")]
+    [TypeConverter(typeof(VerbosityConverter))]
+    [DefaultValue(LogEventLevel.Information)]
+    public LogEventLevel LogLevel { get; set; }
+}
+
+public sealed class VerbosityConverter : TypeConverter
+{
+    private readonly Dictionary<string, LogEventLevel> _lookup;
+
+    public VerbosityConverter()
+    {
+        _lookup = new Dictionary<string, LogEventLevel>(StringComparer.OrdinalIgnoreCase)
+            {
+                {"d", LogEventLevel.Debug},
+                {"v", LogEventLevel.Verbose},
+                {"i", LogEventLevel.Information},
+                {"w", LogEventLevel.Warning},
+                {"e", LogEventLevel.Error},
+                {"f", LogEventLevel.Fatal}
+            };
+    }
+
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+    {
+        if (value is string stringValue)
+        {
+            var result = _lookup.TryGetValue(stringValue, out var verbosity);
+            if (!result)
+            {
+                const string format = "The value '{0}' is not a valid verbosity.";
+                var message = string.Format(CultureInfo.InvariantCulture, format, value);
+                throw new InvalidOperationException(message);
+            }
+            return verbosity;
+        }
+        throw new NotSupportedException("Can't convert value to verbosity.");
+    }
+}

examples/Cli/Logging/Infrastructure/LogInterceptor.cs

@@ -0,0 +1,19 @@
+using Logging.Commands;
+using Serilog.Core;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public class LogInterceptor : ICommandInterceptor
+{
+    public static readonly LoggingLevelSwitch LogLevel = new();
+
+    public void Intercept(CommandContext context, CommandSettings settings)
+    {
+        if (settings is LogCommandSettings logSettings)
+        {
+            LoggingEnricher.Path = logSettings.LogFile ?? "application.log";
+            LogLevel.MinimumLevel = logSettings.LogLevel;
+        }
+    }
+}

examples/Cli/Logging/Infrastructure/LoggingEnricher.cs

@@ -0,0 +1,37 @@
+using Serilog.Core;
+using Serilog.Events;
+
+namespace Logging.Infrastructure;
+
+internal class LoggingEnricher : ILogEventEnricher
+{
+    private string _cachedLogFilePath;
+    private LogEventProperty _cachedLogFilePathProperty;
+
+    // this path and level will be set by the LogInterceptor.cs after parsing the settings
+    public static string Path = string.Empty;
+
+    public const string LogFilePathPropertyName = "LogFilePath";
+
+    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+    {
+        // the settings might not have a path or we might not be within a command in which case
+        // we won't have the setting so a default value for the log file will be required
+        LogEventProperty logFilePathProperty;
+
+        if (_cachedLogFilePathProperty != null && Path.Equals(_cachedLogFilePath))
+        {
+            // Path hasn't changed, so let's use the cached property
+            logFilePathProperty = _cachedLogFilePathProperty;
+        }
+        else
+        {
+            // We've got a new path for the log. Let's create a new property
+            // and cache it for future log events to use
+            _cachedLogFilePath = Path;
+            _cachedLogFilePathProperty = logFilePathProperty = propertyFactory.CreateProperty(LogFilePathPropertyName, Path);
+        }
+
+        logEvent.AddPropertyIfAbsent(logFilePathProperty);
+    }
+}

examples/Cli/Logging/Infrastructure/TypeRegistrar.cs

@@ -0,0 +1,40 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public sealed class TypeRegistrar : ITypeRegistrar
+{
+    private readonly IServiceCollection _builder;
+
+    public TypeRegistrar(IServiceCollection builder)
+    {
+        _builder = builder;
+    }
+
+    public ITypeResolver Build()
+    {
+        return new TypeResolver(_builder.BuildServiceProvider());
+    }
+
+    public void Register(Type service, Type implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterInstance(Type service, object implementation)
+    {
+        _builder.AddSingleton(service, implementation);
+    }
+
+    public void RegisterLazy(Type service, Func<object> func)
+    {
+        if (func is null)
+        {
+            throw new ArgumentNullException(nameof(func));
+        }
+
+        _builder.AddSingleton(service, _ => func());
+    }
+}

examples/Cli/Logging/Infrastructure/TypeResolver.cs

@@ -0,0 +1,24 @@
+using System;
+using Spectre.Console.Cli;
+
+namespace Logging.Infrastructure;
+
+public sealed class TypeResolver : ITypeResolver
+{
+    private readonly IServiceProvider _provider;
+
+    public TypeResolver(IServiceProvider provider)
+    {
+        _provider = provider ?? throw new ArgumentNullException(nameof(provider));
+    }
+
+    public object Resolve(Type type)
+    {
+        if (type == null)
+        {
+            return null;
+        }
+
+        return _provider.GetService(type);
+    }
+}

examples/Cli/Logging/Logging.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <ExampleName>Logging</ExampleName>
+    <ExampleDescription>Demonstrates how to dynamically configure Serilog for logging using parameters from a command.</ExampleDescription>
+    <ExampleGroup>Cli</ExampleGroup>
+    <ExampleVisible>false</ExampleVisible>
+    <Nullable>disable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Serilog" Version="4.0.1" />
+    <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0" />
+    <PackageReference Include="Serilog.Sinks.File" Version="6.0.0" />
+    <PackageReference Include="Serilog.Sinks.Map" Version="2.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Shared.csproj" />
+  </ItemGroup>
+
+</Project>

examples/Cli/Logging/Program.cs

@@ -0,0 +1,54 @@
+using Logging.Commands;
+using Logging.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
+using Serilog;
+using Spectre.Console.Cli;
+
+/*
+ * Dynamically control serilog configuration via command line parameters
+ *
+ * This works around the chicken and egg situation with configuring serilog via the command line.
+ * The logger needs to be configured prior to executing the parser, but the logger needs the parsed values
+ * to be configured. By using serilog.sinks.map we can defer configuration. We use a LogLevelSwitch to control the
+ * logging levels dynamically, and then we use a serilog enricher that has its state populated via a
+ * Spectre.Console CommandInterceptor
+ */
+
+namespace Logging;
+
+public class Program
+{
+    static int Main(string[] args)
+    {
+        // to retrieve the log file name, we must first parse the command settings
+        // this will require us to delay setting the file path for the file writer.
+        // With serilog we can use an enricher and Serilog.Sinks.Map to dynamically
+        // pull this setting.
+        var serviceCollection = new ServiceCollection()
+            .AddLogging(configure =>
+                configure.AddSerilog(new LoggerConfiguration()
+                    // log level will be dynamically be controlled by our log interceptor upon running
+                    .MinimumLevel.ControlledBy(LogInterceptor.LogLevel)
+                    // the log enricher will add a new property with the log file path from the settings
+                    // that we can use to set the path dynamically
+                    .Enrich.With<LoggingEnricher>()
+                    // serilog.sinks.map will defer the configuration of the sink to be ondemand
+                    // allowing us to look at the properties set by the enricher to set the path appropriately
+                    .WriteTo.Map(LoggingEnricher.LogFilePathPropertyName,
+                        (logFilePath, wt) => wt.File($"{logFilePath}"), 1)
+                    .CreateLogger()
+                )
+            );
+
+        var registrar = new TypeRegistrar(serviceCollection);
+        var app = new CommandApp(registrar);
+
+        app.Configure(config =>
+        {
+            config.SetInterceptor(new LogInterceptor()); // add the interceptor
+                config.AddCommand<HelloCommand>("hello");
+        });
+
+        return app.Run(args);
+    }
+}