### Adding Command Usage Examples

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Use WithExample to add one or more usage examples for a command. Each example is provided as a string array of arguments. This is useful for demonstrating how to invoke the command.

```csharp
config.AddCommand<PublishCommand>("publish")
    .WithDescription("Publish the application")
    .WithExample("-e", "production")
    .WithExample("-e", "staging", "--dry-run");
```

--------------------------------

### Enable Example Validation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/application-settings.md

Enables validation of examples at startup to ensure they execute without errors. Defaults to false.

```csharp
config.Settings.ValidateExamples = true;
// Examples that fail to parse will cause startup errors
```

--------------------------------

### Minimal CommandApp Setup

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/quick-reference.md

This snippet shows the basic setup for a CommandApp. It configures the application to add a specific command and then runs it with provided arguments.

```csharp
var app = new CommandApp();
app.Configure(config => config.AddCommand<MyCommand>("cmd"));
await app.RunAsync(args);
```

--------------------------------

### Add Command-Line Usage Examples

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Add examples of command-line arguments to the help text. This helps users understand how to invoke commands with different options.

```csharp
config.AddExample("build", "--release");
config.AddExample("publish", "-e", "prod");
```

--------------------------------

### Example AsyncCommand Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/commands.md

An example of a concrete `AsyncCommand` that performs a file download and provides user feedback upon completion.

```csharp
public class DownloadCommand : AsyncCommand
{
    protected override async Task<int> ExecuteAsync(CommandContext context, CancellationToken cancellationToken)
    {
        await DownloadFileAsync("https://example.com/file.zip", cancellationToken);
        AnsiConsole.MarkupLine("[green]Download complete![/]");
        return 0;
    }
}
```

--------------------------------

### Adding Usage Examples to Help Text

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/advanced-features.md

Usage examples can be added at the application or command level to clarify how to use them. These examples appear in the generated help text.

```csharp
app.Configure(config =>
{
    // Application-level examples
    config.AddExample("build");
    config.AddExample("deploy", "-e", "production");

    config.AddCommand<BuildCommand>("build")
        .WithDescription("Build the project")
        .WithExample("-c", "Debug")
        .WithExample("-c", "Release", "--no-cache");
});
```

--------------------------------

### IConfigurator.AddExample(params string[])

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Adds a usage example to the application's help text, demonstrating command-line argument patterns.

```APIDOC
## IConfigurator.AddExample(params string[])

### Description
Adds a usage example to the application's help text.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### args (`string[]`) - Required - Example command-line arguments.

### Returns
- `IConfigurator` - The same configurator for chaining.

### Example
```csharp
config.AddExample("build", "--release");
config.AddExample("publish", "-e", "prod");
```
```

--------------------------------

### Dependency Injection Setup

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

Demonstrates setting up dependency injection for commands. Services registered with the registrar can be injected into command constructors.

```csharp
var registrar = new DefaultTypeRegistrar();
registrar.Register(typeof(IService), typeof(ServiceImpl));

var app = new CommandApp(registrar);

// Commands receive services in their constructors
public class MyCommand : AsyncCommand<MySettings>
{
    public MyCommand(IService service) { /* ... */ }
}
```

--------------------------------

### Complete Dependency Injection Example

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/dependency-injection.md

A full example demonstrating service definition, registration using `DefaultTypeRegistrar`, and a command that utilizes injected services (`IDataService`). This illustrates the end-to-end DI flow in Spectre.Console.Cli.

```csharp
// 1. Define services
public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine(message);
}

public interface IDataService
{
    Task<string> FetchDataAsync();
}

public class ApiDataService : IDataService
{
    private readonly ILogger _logger;

    public ApiDataService(ILogger logger)
    {
        _logger = logger;
    }

    public async Task<string> FetchDataAsync()
    {
        _logger.Log("Fetching data...");
        return await Task.FromResult("data");
    }
}

// 2. Register services
var registrar = new DefaultTypeRegistrar();
registrar.Register(typeof(ILogger), typeof(ConsoleLogger));
registrar.Register(typeof(IDataService), typeof(ApiDataService));

// 3. Create command using injected services
public class FetchCommand : AsyncCommand<FetchSettings>
{
    private readonly IDataService _dataService;

    public FetchCommand(IDataService dataService)
    {
        _dataService = dataService;
    }

    protected override async Task<int> ExecuteAsync(
        CommandContext context,
        FetchSettings settings,
        CancellationToken cancellationToken)
    {
        var data = await _dataService.FetchDataAsync();
        AnsiConsole.MarkupLine($"[green]Data: {data}[/]");
        return 0;
    }
}

// 4. Create and run app
var app = new CommandApp(registrar);
app.Configure(config =>
{
    config.AddCommand<FetchCommand>("fetch");
});

return await app.RunAsync(args);
```

--------------------------------

### Basic Application Setup

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

This snippet shows how to create a basic CommandApp, configure commands, and run the application. It's the entry point for most CLI applications using this library.

```csharp
var app = new CommandApp();

app.Configure(config =>
{
    config.AddCommand<BuildCommand>("build");
    config.AddCommand<TestCommand>("test");
});

return await app.RunAsync(args);
```

--------------------------------

### Parameter Attribute Examples

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/quick-reference.md

Demonstrates the usage of various parameter attributes for defining command-line arguments and options. Includes examples for positional arguments, named options with optional values, boolean flags, and required options.

```csharp
[CommandArgument(0, "<FILE>")]                    // Required file argument
[CommandArgument(1, "[DESTINATION]")]             // Optional destination
[CommandOption("-o|--output")]                    // Named option
[CommandOption("-v|--verbose [LEVEL]")]           // Optional value
[CommandOption("-f|--flag")]                      // Boolean flag
[CommandOption("-r|--required", isRequired: true)]// Required option
```

--------------------------------

### Custom Help Provider Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Implement the IHelpProvider interface to create custom help documentation. This example shows a compact provider that displays command names and descriptions.

```csharp
public interface IHelpProvider
{
    IEnumerable<IRenderable> Write(ICommandModel model, ICommandInfo? command);
}
```

```csharp
// Custom help provider
public class CompactHelpProvider : IHelpProvider
{
    public IEnumerable<IRenderable> Write(ICommandModel model, ICommandInfo? command)
    {
        if (command != null)
        {
            yield return new Markup($"[bold]{command.Name}[/]\n");
            yield return new Markup(command.Description ?? "");
        }
        else
        {
            yield return new Markup("[bold]Available Commands:[/]\n");
            foreach (var cmd in model.Commands)
            {
                yield return new Markup($"  {cmd.Name} - {cmd.Description}\n");
            }
        }
    }
}
```

--------------------------------

### Default HelpProviderStyle Example

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Applies custom styles to the help provider by creating a new `HelpProviderStyle` instance and configuring its properties.

```csharp
app.Configure(config =>
{
    var styles = new HelpProviderStyle
    {
        Description = new DescriptionStyle
        {
            Header = "bold cyan"
        },
        Usage = new UsageStyle
        {
            Header = "bold green",
            CurrentCommand = "underline green",
            Command = "cyan",
            RequiredArgument = "yellow"
        }
    };
    config.Settings.HelpProviderStyles = styles;
});
```

--------------------------------

### Example AsyncCommand<TSettings> Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/commands.md

A concrete `AsyncCommand` with settings, demonstrating custom validation for a config file and executing a deployment process.

```csharp
public class DeployCommand : AsyncCommand<DeploySettings>
{
    protected override ValidationResult Validate(CommandContext context, DeploySettings settings)
    {
        if (!File.Exists(settings.ConfigFile))
        {
            return ValidationResult.Error($"Config file not found: {settings.ConfigFile}");
        }
        return ValidationResult.Success();
    }

    protected override async Task<int> ExecuteAsync(
        CommandContext context, 
        DeploySettings settings, 
        CancellationToken cancellationToken)
    {
        AnsiConsole.MarkupLine($"[yellow]Deploying to {settings.Environment}...[/]");
        await DeployAsync(settings, cancellationToken);
        AnsiConsole.MarkupLine("[green]Deployment successful![/]");
        return 0;
    }
}
```

--------------------------------

### Configure Application with Commands and Branches

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/quick-reference.md

Use the Configure method to set up your application's name, add commands with descriptions and examples, and define command branches with their own sub-commands.

```csharp
app.Configure(config =>
{
    config.Settings.ApplicationName = "myapp";
    config.AddCommand<BuildCommand>("build")
        .WithDescription("Build the project")
        .WithExample("-c", "Release");
    config.AddBranch<DbSettings>("db", db =>
    {
        db.AddCommand<MigrateCommand>("migrate");
    });
});
```

--------------------------------

### Example: DefaultFromEnvironmentAttribute Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/attributes.md

An example implementation of ParameterValueProviderAttribute that retrieves a parameter's value from an environment variable. Use this when a parameter's default should be dynamically set based on the environment.

```csharp
public class DefaultFromEnvironmentAttribute : ParameterValueProviderAttribute
{
    private readonly string _envVar;

    public DefaultFromEnvironmentAttribute(string envVar)
    {
        _envVar = envVar;
    }

    public override bool TryGetValue(CommandParameterContext context, out object? result)
    {
        result = Environment.GetEnvironmentVariable(_envVar);
        return result != null;
    }
}

public class DeploySettings : CommandSettings
{
    [CommandOption("-e|--environment")]
    [DefaultFromEnvironment("DEPLOY_ENV")]
    public string Environment { get; set; }
}
```

--------------------------------

### ExampleStyle Class Definition

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Defines the style for usage examples, including the header and arguments.

```csharp
public sealed class ExampleStyle
{
    public Style? Header { get; set; }
    public Style? Arguments { get; set; }
}
```

--------------------------------

### Implement Custom Help Provider

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Example of implementing a custom IHelpProvider to render detailed command help or application-wide command lists using Spectre.Console's Grid and Renderable types.

```csharp
public class VerboseHelpProvider : IHelpProvider
{
    public IEnumerable<IRenderable> Write(ICommandModel model, ICommandInfo? command)
    {
        if (command != null)
        {
            yield return RenderCommandHelp(command);
        }
        else
        {
            yield return RenderApplicationHelp(model);
        }
    }

    private IRenderable RenderCommandHelp(ICommandInfo command)
    {
        var grid = new Grid();
        grid.AddColumn(new GridColumn().Padding(1, 0));
        grid.AddColumn(new GridColumn().Padding(1, 0));

        grid.AddRow("[bold]Command[/]", command.Name);
        if (!string.IsNullOrEmpty(command.Description))
        {
            grid.AddRow("[bold]Description[/]", command.Description);
        }

        return grid;
    }

    private IRenderable RenderApplicationHelp(ICommandModel model)
    {
        var grid = new Grid();
        grid.AddColumn(new GridColumn().Padding(1, 0));
        grid.AddColumn(new GridColumn().Padding(1, 0));

        grid.AddRow("[bold]Available Commands[/]", "");
        foreach (var cmd in model.Commands.Where(c => !c.IsHidden))
        {
            grid.AddRow($"  {cmd.Name}", cmd.Description ?? "");
        }

        return grid;
    }
}

// Usage
app.Configure(config =>
{
    config.SetHelpProvider<VerboseHelpProvider>();
});
```

--------------------------------

### Set Maximum Indirect Examples

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/application-settings.md

Control the maximum number of examples from direct child commands to display in parent help text. Defaults to 5.

```csharp
config.Settings.MaximumIndirectExamples = 3;
```

--------------------------------

### ICommandInfo Interface

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Provides information about a specific command, including its name, description, parameters, subcommands, and usage examples.

```csharp
public interface ICommandInfo
{
    string Name { get; }
    string? Description { get; }
    IReadOnlyList<ICommandParameter> Parameters { get; }
    IReadOnlyList<ICommandInfo> Children { get; }
    bool IsHidden { get; }
    IReadOnlyList<string[]> Examples { get; }
}
```

--------------------------------

### LoggingInterceptor Example (Deprecated)

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/advanced-features.md

Demonstrates a deprecated pattern for implementing ICommandInterceptor to log command execution details. The preferred approach involves registering the interceptor with ITypeRegistrar.

```csharp
public class LoggingInterceptor : ICommandInterceptor
{
    public void Intercept(CommandContext context, CommandSettings settings)
    {
        AnsiConsole.MarkupLine($"[dim]Executing command: {context.Name}[/]");
    }

    public void InterceptResult(CommandContext context, CommandSettings settings, ref int result)
    {
        AnsiConsole.MarkupLine($"[dim]Exit code: {result}[/]");
    }
}

// Preferred approach: Register via type registrar
registrar.Register(typeof(ICommandInterceptor), typeof(LoggingInterceptor));
```

--------------------------------

### HelpProviderStyle Class

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

Defines the styling configuration for help text, allowing customization of descriptions, usage lines, examples, arguments, options, and commands.

```APIDOC
## Class: HelpProviderStyle

### Description
Help text styling configuration.

### Properties
- `DescriptionStyle? Description` — Description styling
- `UsageStyle? Usage` — Usage line styling
- `ExampleStyle? Examples` — Examples styling
- `ArgumentStyle? Arguments` — Arguments styling
- `OptionStyle? Options` — Options styling
- `CommandStyle? Commands` — Commands styling
- `static HelpProviderStyle Default` — Default styles
```

--------------------------------

### ICommandInfo

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

Provides information about a specific command, including its name, description, parameters, subcommands, and examples.

```APIDOC
## ICommandInfo

Command information.

### Properties

- `string Name` — Command name
- `string? Description` — Description
- `IReadOnlyList<ICommandParameter> Parameters` — Arguments and options
- `IReadOnlyList<ICommandInfo> Children` — Subcommands
- `bool IsHidden` — Is hidden
- `IReadOnlyList<string[]> Examples` — Usage examples
```

--------------------------------

### Example Usage of FlagValue<T>

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/types.md

Demonstrates how to declare and use a FlagValue<T> for a command-line option, such as a verbose flag with an optional level. Shows how to check if the flag is set and access its value.

```csharp
[CommandOption("-v|--verbose [LEVEL]")]
public FlagValue<string> Verbose { get; set; }
```

```csharp
if (settings.Verbose.IsSet)
{
    var level = settings.Verbose.Value ?? "default";
}
```

--------------------------------

### Branched Commands

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

Shows how to group related commands under a common branch. This example creates a 'db' branch with 'migrate' and 'seed' commands, allowing for organized command-line interfaces.

```APIDOC
## Branched Commands

### Description
Organizes commands into logical groups using branches. This example creates a 'db' branch containing 'migrate' and 'seed' commands.

### Method
`AddBranch`, `AddCommand`

### Endpoint
N/A (SDK Usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
config.AddBranch<DbSettings>("db", db =>
{
    db.AddCommand<MigrateCommand>("migrate");
    db.AddCommand<SeedCommand>("seed");
});

// Usage: myapp db migrate, myapp db seed
```

### Response
N/A (Configuration step)
```

--------------------------------

### Set Case Sensitivity in Configuration

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/types.md

Example of how to apply the CaseSensitivity enum to the application's configuration settings. This is typically done during the application's setup phase.

```csharp
config.Settings.CaseSensitivity = CaseSensitivity.All;
```

--------------------------------

### FileExistsAttribute Example

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/attributes.md

An example implementation of a custom validation attribute that checks if a file exists. Use this to ensure a provided file path is valid.

```csharp
public class FileExistsAttribute : ParameterValidationAttribute
{
    public FileExistsAttribute()
        : base("File does not exist.")
    {
    }

    public override ValidationResult Validate(CommandParameterContext context)
    {
        if (context.Value is not string path)
        {
            return ValidationResult.Success();
        }

        if (!File.Exists(path))
        {
            return ValidationResult.Error(ErrorMessage);
        }

        return ValidationResult.Success();
    }
}

public class DeploySettings : CommandSettings
{
    [CommandArgument(0, "<SCRIPT>")]
    [FileExists]
    public string ScriptPath { get; set; }
}
```

--------------------------------

### Command with Options

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/quick-reference.md

Illustrates how to define and use command-line options, including required options and boolean flags. Options are defined as properties in the settings class.

```csharp
public class MySettings : CommandSettings
{
    [CommandOption("-o|--output", isRequired: true)]
    public string Output { get; set; }

    [CommandOption("-v|--verbose")]
    public bool Verbose { get; set; }
}
```

--------------------------------

### Build Application with Release Configuration

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Build your application using the Release configuration. This is a common command for preparing production builds.

```bash
# Build with Release configuration
myapp build -c Release
```

--------------------------------

### IConfigurator

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

The primary configurator for defining the overall application structure, including global settings, help providers, examples, and commands.

```APIDOC
## Interface IConfigurator

### Description
Primary configurator for application structure.

### Properties
- `ICommandAppSettings Settings` — Global application settings

### Methods
- `SetHelpProvider(IHelpProvider)` — Custom help provider instance
- `SetHelpProvider<T>()` — Custom help provider by type
- `AddExample(params string[])` — Application usage example
- `AddCommand<T>(string)` — Add command
- `AddDelegate<T>(string, Func<...>)` — Add sync delegate command
- `AddAsyncDelegate<T>(string, Func<...>)` — Add async delegate command
- `AddBranch<T>(string, Action<...>)` — Add command branch
```

--------------------------------

### Command with Parameters

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

Illustrates how to define a command with custom settings, including command arguments and options. The `BuildSettings` class inherits from `CommandSettings` to define parameters, and `BuildCommand` implements `AsyncCommand` to execute the command logic.

```APIDOC
## Command with Parameters

### Description
Defines a command that accepts parameters. `BuildSettings` specifies a required `<TARGET>` argument and an optional `--config` option. `BuildCommand` executes the logic using these settings.

### Method
`ExecuteAsync`

### Endpoint
N/A (SDK Usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
public class BuildSettings : CommandSettings
{
    [CommandArgument(0, "<TARGET>")]
    public string Target { get; set; }

    [CommandOption("-c|--config")]
    public string Config { get; set; } = "Release";
}

public class BuildCommand : AsyncCommand<BuildSettings>
{
    protected override async Task<int> ExecuteAsync(
        CommandContext context,
        BuildSettings settings,
        CancellationToken cancellationToken)
    {
        // Implement command logic
        return 0;
    }
}
```

### Response
#### Success Response
Returns an integer representing the exit code of the command execution.

#### Response Example
`0` (for success)
```

--------------------------------

### CommandApp<TDefaultCommand>

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

A specialized application class that comes with a pre-configured default command, simplifying the setup for common CLI structures.

```APIDOC
## CommandApp<TDefaultCommand>

### Description
Specialized application with a pre-configured default command.

### Methods
- Same as CommandApp
- `WithDescription(string)`: Set default command description.
- `WithData(object)`: Pass context data to the default command.

### Constructors
- `CommandApp(ITypeRegistrar?)`: Auto-sets TDefaultCommand as the default command.
```

--------------------------------

### CommandApp Basic Application

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

Demonstrates the basic structure for creating and running a CLI application using `CommandApp`. It shows how to configure commands and execute the application with provided arguments.

```APIDOC
## CommandApp Basic Application

### Description
This example shows how to instantiate `CommandApp`, configure it with commands like 'build' and 'test', and then run the application.

### Method
`RunAsync`

### Endpoint
N/A (SDK Usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
var app = new CommandApp();

app.Configure(config =>
{
    config.AddCommand<BuildCommand>("build");
    config.AddCommand<TestCommand>("test");
});

return await app.RunAsync(args);
```

### Response
#### Success Response
Returns an integer representing the exit code of the application.

#### Response Example
`0` (for success)
```

--------------------------------

### Accessing Default HelpProviderStyle

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/types.md

Demonstrates how to retrieve the predefined default styles for help text rendering and apply them to application settings.

```csharp
var styles = HelpProviderStyle.Default;
config.Settings.HelpProviderStyles = styles;
```

--------------------------------

### ICommandConfigurator

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

A fluent configurator designed for customizing individual commands, allowing for the addition of descriptions, examples, aliases, and hiding commands from help.

```APIDOC
## Interface ICommandConfigurator

### Description
Fluent configurator for individual commands.

### Methods
- `WithDescription(string)` — Help text
- `WithExample(params string[])` — Usage example
- `WithAlias(string)` — Alternative command name
- `WithData(object)` — Context data
- `IsHidden()` — Hide from help
```

--------------------------------

### Program.cs - Main Entry Point

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

This C# code configures and runs a command-line application using Spectre.Console.Cli. It sets up dependency injection, defines application metadata and behavior, registers commands and branches, and handles exceptions.

```csharp
using Spectre.Console;
using Spectre.Console.Cli;

// 1. Setup dependency injection
var registrar = new DefaultTypeRegistrar();
registrar.Register(typeof(ILogger), typeof(ConsoleLogger));
registrar.Register(typeof(ICompiler), typeof(DotNetCompiler));

// 2. Create the application
var app = new CommandApp(registrar);

// 3. Configure the application
app.Configure(config =>
{
    // Application metadata
    config.Settings.ApplicationName = "myapp";
    config.Settings.ApplicationVersion = "1.0.0";
    
    // Help behavior
    config.Settings.ShowOptionDefaultValues = true;
    config.Settings.CaseSensitivity = CaseSensitivity.None;
    
    // Exception handling
    config.Settings.ExceptionHandler = (ex, resolver) =>
    {
        var logger = resolver?.Resolve(typeof(ILogger)) as ILogger;
        logger?.Error($"Application error: {ex.Message}");
        return ex is CommandParseException ? 1 : -1;
    };
    
    // Add commands
    config.AddCommand<BuildCommand>("build")
        .WithDescription("Build the project")
        .WithExample("-c", "Release")
        .WithExample("-c", "Debug", "--watch");
    
    config.AddCommand<TestCommand>("test")
        .WithDescription("Run tests")
        .WithExample("--filter", "Category=Unit")
        .WithAlias("t");
    
    config.AddBranch<DeploySettings>("deploy", deploy =>
    {
        deploy.AddCommand<DeployCommand>("production")
            .WithDescription("Deploy to production");
        deploy.AddCommand<DeployCommand>("staging")
            .WithDescription("Deploy to staging");
    });
    
    config.AddExample("build", "-c", "Release");
    config.AddExample("test", "--coverage");
    config.AddExample("deploy", "production");
});

// 4. Run the application
return await app.RunAsync(args);

```

--------------------------------

### IConfigurator<TSettings>

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

A specialized configurator for branches that utilize a specific settings type, allowing for branch-specific descriptions, examples, and command additions.

```APIDOC
## Interface IConfigurator<TSettings>

### Description
Configurator for branches with specific settings type.

### Methods
- `SetDescription(string)` — Branch description
- `AddExample(params string[])` — Branch example
- `SetDefaultCommand<T>()` — Default for branch
- `HideBranch()` — Hide from help
- `AddCommand<T>(string)` — Add command to branch
- `AddDelegate<T>(string, Func<...>)` — Sync delegate
- `AddAsyncDelegate<T>(string, Func<...>)` — Async delegate
- `AddBranch<T>(string, Action<...>)` — Nested branch
```

--------------------------------

### Build Settings with Command Options

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Defines command-line arguments for a build process, including configuration, watch mode, output directory, and verbose logging. Includes custom validation for the output path.

```csharp
using Spectre.Console.Cli;
using System.ComponentModel;
using System.IO;

public class BuildSettings : CommandSettings
{
    [CommandOption("-c|--configuration")]
    [Description("Build configuration")]
    [TypeConverter(typeof(EnumConverter<BuildConfiguration>))]
    public BuildConfiguration Configuration { get; set; } = BuildConfiguration.Release;

    [CommandOption("-w|--watch")]
    [Description("Watch for changes and rebuild")]
    public bool Watch { get; set; }

    [CommandOption("-o|--output")]
    [Description("Output directory")]
    public string? Output { get; set; }

    [CommandOption("-v|--verbose [LEVEL]")]
    [Description("Verbose logging level")]
    public FlagValue<string> Verbose { get; set; }

    public override ValidationResult Validate()
    {
        if (Output != null && Path.IsPathRooted(Output))
        {
            return ValidationResult.Error("Output path must be relative");
        }
        return ValidationResult.Success();
    }
}

public enum BuildConfiguration
{
    Debug,
    Release
}
```

--------------------------------

### Instantiate CommandApp

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Create a new CommandApp instance. Optionally provide a custom type registrar for dependency injection.

```csharp
var app = new CommandApp();
```

```csharp
var registrar = new MyCustomTypeRegistrar();
var app = new CommandApp(registrar);
```

--------------------------------

### Show Help Information

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Display help information for the CLI tool or specific commands. This is essential for understanding available options and usage.

```bash
# Show help
myapp --help
myapp build --help
myapp deploy --help
```

--------------------------------

### Configure Case Sensitivity

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/application-settings.md

Sets the case sensitivity for CLI elements. Examples show making only commands case-sensitive, making all elements case-sensitive, or combining options.

```csharp
// Make only commands case-sensitive
config.Settings.CaseSensitivity = CaseSensitivity.Commands;

// Make both case-sensitive
config.Settings.CaseSensitivity = CaseSensitivity.All;

// Or combine with bitwise OR
config.Settings.CaseSensitivity = 
    CaseSensitivity.Commands | CaseSensitivity.LongOptions;
```

--------------------------------

### Configure Method

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Configures the application structure, commands, and settings using a provided configuration action.

```APIDOC
## Configure Method

### Description
Configures the application structure, commands, and settings using a provided configuration action.

### Method
`void Configure(Action<IConfigurator> configuration)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **configuration** (`Action<IConfigurator>`) - Required - Lambda that configures the application.

### Throws
`ArgumentNullException` if configuration is null.

### Example
```csharp
app.Configure(config =>
{
    config.SetApplicationName("myapp");
    config.AddCommand<InitCommand>("init");
    config.AddCommand<BuildCommand>("build");
});
```
```

--------------------------------

### Deploy Application to Production with Version Confirmation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Deploy your application to the production environment, specifying the version and requiring confirmation. This ensures safe production deployments.

```bash
# Deploy to production with confirmation
myapp deploy production --version 1.0.0
```

--------------------------------

### Run Method

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Synchronously executes the application with the provided command-line arguments and an optional cancellation token.

```APIDOC
## Run Method

### Description
Synchronously executes the application with the provided command-line arguments and an optional cancellation token.

### Method
`int Run(IEnumerable<string> args, CancellationToken cancellationToken = default)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **args** (`IEnumerable<string>`) - Required - Command-line arguments.
- **cancellationToken** (`CancellationToken`) - Optional - Token to cancel command execution.

### Returns
Integer exit code (0 for success, non-zero for failure).

### Example
```csharp
var exitCode = app.Run(new[] { "build", "--output", "dist" });
Environment.Exit(exitCode);
```
```

--------------------------------

### Run

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Synchronously executes the application with the provided command-line arguments and an optional cancellation token.

```APIDOC
## int Run(IEnumerable<string> args, CancellationToken cancellationToken = default)

### Description
Synchronously executes the application.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **args** (`IEnumerable<string>`) - Required - Command-line arguments.
- **cancellationToken** (`CancellationToken`) - Optional - Cancellation token.

### Returns
Integer exit code.
```

--------------------------------

### Deploy Application to Staging Environment

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Deploy your application to the staging environment. This command is typically used for pre-production testing.

```bash
# Deploy to staging
myapp deploy staging
```

--------------------------------

### Resolve Service in Validation Handler

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/dependency-injection.md

Example of resolving an `ILogger` service within a parameter validation handler using `ITypeResolver`. Ensure the service is registered before attempting to resolve it.

```csharp
public override ValidationResult Validate(CommandParameterContext context)
{
    var logger = context.Resolver.Resolve(typeof(ILogger));
    logger?.LogInformation("Validating parameter...");
    return ValidationResult.Success();
}
```

--------------------------------

### IHelpProvider Interface

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

Interface for providing help documentation for commands. Implementations generate help text based on command models.

```APIDOC
## Interface: IHelpProvider

### Description
Help documentation interface.

### Methods
- `IEnumerable<IRenderable> Write(ICommandModel, ICommandInfo?)` — Generate help
```

--------------------------------

### DefaultCommandConfigurator.WithDescription

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Sets the description for the default command, which is displayed in the help text.

```APIDOC
## DefaultCommandConfigurator.WithDescription

### Description
Sets the default command description.

### Method
`DefaultCommandConfigurator WithDescription(string description)`

### Parameters
#### Path Parameters
- **description** (`string`) - Yes - Description.

### Response
Returns the same configurator for chaining.
```

--------------------------------

### Setting Command Description

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Use WithDescription to set the command's description, which will be displayed in the help text. This method is part of a fluent configurator chain.

```csharp
public interface ICommandConfigurator
{
    ICommandConfigurator WithDescription(string description);
}
```

--------------------------------

### ICommandConfigurator Interface

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

The ICommandConfigurator interface provides a fluent API for configuring individual commands within the Spectre.Console CLI. It allows developers to customize how commands are presented in help text, add usage examples, define alternative names (aliases), pass contextual data, and control command visibility.

```APIDOC
## ICommandConfigurator Interface

Provides methods for configuring individual commands.

### Methods

#### `ICommandConfigurator WithDescription(string description)`

Sets the command description shown in help text.

- **description** (`string`): Required - Command description.

**Returns:** The same configurator for chaining.

#### `ICommandConfigurator WithExample(params string[] args)`

Adds a usage example for this command.

- **args** (`string[]`): Required - Example arguments (without command name).

**Returns:** The same configurator for chaining.

**Example:**
```csharp
config.AddCommand<PublishCommand>("publish")
    .WithDescription("Publish the application")
    .WithExample("-e", "production")
    .WithExample("-e", "staging", "--dry-run");
```

#### `ICommandConfigurator WithAlias(string name)`

Adds an alternative name for the command.

- **name** (`string`): Required - Alias name.

**Returns:** The same configurator for chaining.

**Example:**
```csharp
config.AddCommand<BuildCommand>("build")
    .WithAlias("b")
    .WithAlias("compile");
// Usage: myapp build, myapp b, or myapp compile
```

#### `ICommandConfigurator WithData(object data)`

Passes context data to the command via CommandContext.

- **data** (`object`): Required - Context data.

**Returns:** The same configurator for chaining.

**Example:**
```csharp
config.AddCommand<InitCommand>("init")
    .WithData(new { Version = "1.0", Author = "Team" });
```

#### `ICommandConfigurator IsHidden()`

Hides the command from help text and XML documentation.

**Returns:** The same configurator for chaining.
```

--------------------------------

### WithDescription

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Sets the description of the default command and returns the same instance for method chaining.

```APIDOC
## CommandApp<TDefaultCommand> WithDescription(string description)

### Description
Sets the description of the default command.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **description** (`string`) - Required - The command description.

### Returns
The same instance for method chaining.

### Example
```csharp
app.WithDescription("My application does amazing things");
```
```

--------------------------------

### Configure Help Provider

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/quick-reference.md

Set a custom help provider by type or instance using config.SetHelpProvider. Styles for help output can be configured via Settings.HelpProviderStyles.

```csharp
// Custom help provider
config.SetHelpProvider<MyHelpProvider>();

// Or instance
config.SetHelpProvider(new MyHelpProvider());

// Style configuration
config.Settings.HelpProviderStyles = new HelpProviderStyle
{
    Usage = new UsageStyle { Header = "bold cyan" }
};
```

--------------------------------

### Configure Application Settings

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/application-settings.md

Demonstrates a comprehensive configuration of application settings for a CommandApp. This includes setting application metadata, customizing help rendering, defining parsing behavior, implementing custom error handling, enabling validation, and adding commands.

```csharp
var app = new CommandApp();

app.Configure(config =>
{
    // Application metadata
    config.Settings.ApplicationName = "myapp";
    config.Settings.ApplicationVersion = "1.2.3";
    config.Settings.Culture = new CultureInfo("en-US");
    
    // Help rendering
    config.Settings.ShowOptionDefaultValues = true;
    config.Settings.TrimTrailingPeriod = false;
    config.Settings.MaximumIndirectExamples = 3;
    
    // Parsing behavior
    config.Settings.CaseSensitivity = CaseSensitivity.Commands;
    config.Settings.StrictParsing = false;
    config.Settings.ConvertFlagsToRemainingArguments = false;
    
    // Error handling
    config.Settings.PropagateExceptions = false;
    config.Settings.CancellationExitCode = 130;
    config.Settings.ExceptionHandler = (ex, resolver) =>
    {
        AnsiConsole.MarkupLine($"[red]Error:[/]
 {ex.Message}");
        return -1;
    };
    
    // Validation
    config.Settings.ValidateExamples = true;
    
    // Commands
    config.AddCommand<BuildCommand>("build");
    config.AddCommand<DeployCommand>("deploy");
});

return await app.RunAsync(args);
```

--------------------------------

### Build Application with Verbose Debug Output

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Build your application with verbose debug output and enable watch mode for continuous rebuilding during development.

```bash
# Build with verbose output
myapp build -v debug --watch
```

--------------------------------

### IConfigurator.SetHelpProvider<T>()

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Sets a help provider by type, allowing the framework to instantiate it at runtime.

```APIDOC
## IConfigurator.SetHelpProvider<T>()

### Description
Sets a help provider by type; the framework instantiates it.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Type Parameters
- `T` - Help provider type to instantiate at runtime.

### Returns
- `IConfigurator` - The same configurator for chaining.

### Example
```csharp
// Assuming 'app' is an instance of your application configuration
// and 'MyCustomHelpProvider' is a class implementing IHelpProvider
// app.Configure(config => config.SetHelpProvider<MyCustomHelpProvider>());
```
```

--------------------------------

### Define Command Settings with Options and Arguments

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

Define a class that inherits from CommandSettings to specify command-line options and arguments. Use attributes like [CommandOption] and [CommandArgument] to map them.

```csharp
using Spectre.Console.Cli;

public class TestSettings : CommandSettings
{
    [CommandOption("--filter")]
    public string? Filter { get; set; }

    [CommandOption("--coverage")]
    public bool Coverage { get; set; }

    [CommandOption("-v|--verbose")]
    public bool Verbose { get; set; }

    [CommandArgument(0, "[PROJECT]")]
    public string? Project { get; set; }
}
```

```csharp
using Spectre.Console.Cli;

public class DeploySettings : CommandSettings
{
    [CommandOption("--version")]
    public string? Version { get; set; }

    [CommandOption("--dry-run")]
    public bool DryRun { get; set; }

    [CommandOption("-y|--yes")]
    public bool AutoConfirm { get; set; }
}
```

--------------------------------

### DeploySettings Class

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/commands.md

Defines the settings for the DeployCommand, including environment and configuration file options, with default values.

```csharp
public class DeploySettings : CommandSettings
{
    [CommandOption("-e|--environment")]
    public string Environment { get; set; } = "staging";

    [CommandOption("-c|--config")]
    public string ConfigFile { get; set; } = "appsettings.json";
}
```

--------------------------------

### DotNet Compiler Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

A sample implementation of an ICompiler interface that uses an ILogger to report compilation status. Demonstrates asynchronous compilation and logging.

```csharp
using System.Threading;
using System.Threading.Tasks;

public interface ICompiler
{
    Task<bool> CompileAsync(BuildSettings settings, CancellationToken ct);
}

public class DotNetCompiler : ICompiler
{
    private readonly ILogger _logger;

    public DotNetCompiler(ILogger logger)
    {
        _logger = logger;
    }

    public async Task<bool> CompileAsync(BuildSettings settings, CancellationToken ct)
    {
        _logger.Info($"Compiling in {settings.Configuration} mode...");
        
        // Simulate compilation
        await Task.Delay(2000, ct);
        
        _logger.Success("Compilation successful");
        return true;
    }
}
```

--------------------------------

### Deployment Command Implementation

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/complete-example.md

This C# code defines a command for deploying an application. It handles environment-specific logic, prompts for confirmation unless auto-confirm is enabled, and simulates the deployment process with a progress bar. Use this for commands that manage application deployments.

```csharp
using Spectre.Console;
using Spectre.Console.Cli;

public class DeployCommand : AsyncCommand<DeploySettings>
{
    private readonly ILogger _logger;

    public DeployCommand(ILogger logger)
    {
        _logger = logger;
    }

    protected override async Task<int> ExecuteAsync(
        CommandContext context,
        DeploySettings settings,
        CancellationToken cancellationToken)
    {
        var environment = context.Name == "production" ? "Production" : "Staging";

        _logger.Warning($"Deploying to {environment}...");

        if (!settings.AutoConfirm)
        {
            var confirm = AnsiConsole.Confirm(
                $"[yellow]Are you sure you want to deploy to {environment}?[/]");
            
            if (!confirm)
            {
                _logger.Warning("Deployment cancelled");
                return 1;
            }
        }

        if (settings.DryRun)
        {
            _logger.Info("[yellow]DRY RUN:[/] No changes will be made");
        }

        // Simulate deployment
        await AnsiConsole.Progress()
            .StartAsync(async ctx =>
            {
                var task = ctx.AddTask("[cyan]Deploying...[/]");
                while (!task.IsFinished)
                {
                    await Task.Delay(100, cancellationToken);
                    task.Increment(10);
                }
            });

        _logger.Success($"Successfully deployed to {environment}");
        return 0;
    }
}
```

--------------------------------

### Registering a Custom Help Provider

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Register your custom IHelpProvider implementation with the application configuration. This can be done by directly providing an instance or by specifying the type.

```csharp
// Register custom provider
app.Configure(config =>
{
    config.SetHelpProvider(new CompactHelpProvider());
    // Or by type:
    // config.SetHelpProvider<CompactHelpProvider>();
});
```

--------------------------------

### Checkout Main Branch

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/CONTRIBUTING.md

Switches to the main branch of your local repository.

```bash
git checkout main
```

--------------------------------

### IConfigurator.SetHelpProvider(IHelpProvider)

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/configurators.md

Sets a custom help provider implementation for the application.

```APIDOC
## IConfigurator.SetHelpProvider(IHelpProvider)

### Description
Sets a custom help provider implementation.

### Method
POST

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### helpProvider (`IHelpProvider`) - Required - The help provider instance.

### Returns
- `IConfigurator` - The same configurator for chaining.

### Example
```csharp
// Assuming 'app' is an instance of your application configuration
// and 'myHelpProvider' is an instance of a class implementing IHelpProvider
// app.Configure(config => config.SetHelpProvider(myHelpProvider));
```
```

--------------------------------

### RunAsync Method

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Asynchronously executes the application with the provided command-line arguments and an optional cancellation token.

```APIDOC
## RunAsync Method

### Description
Asynchronously executes the application with the provided command-line arguments and an optional cancellation token.

### Method
`Task<int> RunAsync(IEnumerable<string> args, CancellationToken cancellationToken = default)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **args** (`IEnumerable<string>`) - Required - Command-line arguments.
- **cancellationToken** (`CancellationToken`) - Optional - Token to cancel command execution.

### Returns
Task<int> resolving to the exit code.

### Example
```csharp
var exitCode = await app.RunAsync(args);
return exitCode;
```
```

--------------------------------

### Define CommandApp with Default Command

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Instantiate a CommandApp with a specific default command, such as HelpCommand. This is useful for applications that always run a default command.

```csharp
var app = new CommandApp<HelpCommand>();
```

--------------------------------

### CommandApp

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/api-summary.md

Represents the entry point for building CLI applications. It orchestrates command registration and execution, allowing for configuration and running of commands.

```APIDOC
## CommandApp

### Description
Entry point for building CLI applications. Orchestrates command registration and execution.

### Methods
- `Configure(Action<IConfigurator>)`: Set up commands and settings.
- `Run(IEnumerable<string>, CancellationToken?)`: Execute synchronously.
- `RunAsync(IEnumerable<string>, CancellationToken?)`: Execute asynchronously.
- `SetDefaultCommand<T>()`: Set command that runs when no subcommand is given.

### Constructors
- `CommandApp(ITypeRegistrar?)`: Initialize with an optional DI container.
```

--------------------------------

### Dependency Injection

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/README.md

Demonstrates how to integrate dependency injection into the CLI application. A custom `ITypeRegistrar` can be provided to the `CommandApp` constructor to register services that can then be injected into commands.

```APIDOC
## Dependency Injection

### Description
Enables dependency injection within commands by providing a custom `ITypeRegistrar`. Services registered with the registrar can be injected into command constructors.

### Method
`CommandApp` constructor with `ITypeRegistrar`

### Endpoint
N/A (SDK Usage)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
var registrar = new DefaultTypeRegistrar();
registrar.Register(typeof(IService), typeof(ServiceImpl));

var app = new CommandApp(registrar);

// Commands receive services in their constructors
public class MyCommand : AsyncCommand<MySettings>
{
    public MyCommand(IService service) { /* ... */ }
}
```

### Response
N/A (Configuration step)
```

--------------------------------

### RunAsync

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Asynchronously executes the application with the provided command-line arguments and an optional cancellation token.

```APIDOC
## Task<int> RunAsync(IEnumerable<string> args, CancellationToken cancellationToken = default)

### Description
Asynchronously executes the application.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **args** (`IEnumerable<string>`) - Required - Command-line arguments.
- **cancellationToken** (`CancellationToken`) - Optional - Cancellation token.

### Returns
Task<int> resolving to the exit code.
```

--------------------------------

### Define a Command Settings Class with Arguments and Options

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-settings.md

Create a derived class from CommandSettings to define various command-line parameters including arguments, options, and flags. Provide default values and specify types.

```csharp
public class BuildSettings : CommandSettings
{
    [CommandArgument(0, "[TARGET]")]
    public string Target { get; set; } = "Release";

    [CommandOption("-o|--output")]
    public string Output { get; set; }

    [CommandOption("-w|--warnings-as-errors")]
    public bool WarningsAsErrors { get; set; }

    [CommandOption("-v|--verbose")]
    public FlagValue<string> Verbose { get; set; }

    public override ValidationResult Validate()
    {
        if (!string.IsNullOrEmpty(Output) && Path.IsPathRooted(Output))
        {
            return ValidationResult.Error("Output path must be relative");
        }
        return ValidationResult.Success();
    }
}
```

--------------------------------

### HelpProviderStyle Class Definition

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/help-system.md

Defines the structure for customizing colors and formatting in help text.

```csharp
public sealed class HelpProviderStyle
```

--------------------------------

### Configure

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Configures additional commands and settings beyond the default command using a provided configuration action.

```APIDOC
## void Configure(Action<IConfigurator> configuration)

### Description
Configures additional commands and settings beyond the default command.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **configuration** (`Action<IConfigurator>`) - Required - Lambda to configure the application.

### Example
```csharp
app.Configure(config =>
{
    config.AddCommand<BuildCommand>("build");
});
```
```

--------------------------------

### CommandApp Constructor

Source: https://github.com/spectreconsole/spectre.console.cli/blob/main/_autodocs/command-app.md

Initializes a new instance of the CommandApp class. It can optionally accept a custom type registrar for dependency injection.

```APIDOC
## CommandApp Constructor

### Description
Initializes a new instance of the CommandApp class. It can optionally accept a custom type registrar for dependency injection.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Constructor Signature
`public sealed class CommandApp : ICommandApp`

`public CommandApp(ITypeRegistrar? registrar = null)`

### Parameters
- **registrar** (`ITypeRegistrar`) - Optional - Dependency injection registrar for resolving command and settings types. When null, a DefaultTypeRegistrar is created.

### Example
```csharp
// Minimal setup
var app = new CommandApp();

// With custom dependency injection
var registrar = new MyCustomTypeRegistrar();
var app = new CommandApp(registrar);
```
```