### Spectre.Console Quick Start Example

Source: https://spectreconsole.net/console

A basic example demonstrating styled text with markup, a simple table, and a status spinner. Ensure you have the necessary using statements for Spectre.Console and System.Threading.

```csharp
// Styled text with markup
AnsiConsole.MarkupLine("[bold blue]Welcome[/] to [green]Spectre.Console[/]!");
  
// A simple table
var table = new Table()
    .AddColumn("Feature")
    .AddColumn("Description")
    .AddRow("[green]Markup[/]", "Rich text with colors and styles")
    .AddRow("[blue]Tables[/]", "Structured data display")
    .AddRow("[yellow]Progress[/]", "Spinners and progress bars");
AnsiConsole.Write(table);
  
// Status spinner for work
AnsiConsole.Status()
    .Start("Processing...", ctx =>
    {
        Thread.Sleep(2500);
    });
  
AnsiConsole.MarkupLine("[green]Done![/]");

```

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

### TreeGuide.Ascii Example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Renders a tree structure using the Ascii tree guide. This guide uses basic ASCII characters.

```text
Root
|-- Child 1
|   |-- Grandchild 1.1
|   `-- Grandchild 1.2
`-- Child 2
    |-- Grandchild 2.1
    `-- Grandchild 2.2
```

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

### TreeGuide.Line Example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Renders a tree structure using the Line tree guide. This guide uses single-line Unicode box-drawing characters.

```text
Root
├── Child 1
│   ├── Grandchild 1.1
│   └── Grandchild 1.2
└── Child 2
    ├── Grandchild 2.1
    └── Grandchild 2.2
```

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

### Create and Render a Tree with Line Guide

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Demonstrates how to create a tree structure and render it using the default Line guide. Ensure your terminal supports Unicode for certain tree guides.

```csharp
var tree = new Tree("Root");
tree.Guide(TreeGuide.Line);
  
var node1 = tree.AddNode("Child 1");
node1.AddNode("Grandchild 1.1");
node1.AddNode("Grandchild 1.2");
  
tree.AddNode("Child 2");
  
AnsiConsole.Write(tree);
```

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

### Explain Command Examples

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Provides examples of using the explain command with different options to control the output. Use --detailed for parameter information and --hidden to include hidden commands.

```bash
myapp cli explain                    # Show all commands
myapp cli explain add                # Show specific command
myapp cli explain --detailed         # Show parameter details
myapp cli explain --hidden           # Include hidden items
```

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

### TreeGuide.DoubleLine Example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Renders a tree structure using the DoubleLine tree guide. This guide uses double-line Unicode box-drawing characters.

```text
Root
╠══ Child 1
║   ╠══ Grandchild 1.1
║   ╚══ Grandchild 1.2
╚══ Child 2
    ╠══ Grandchild 2.1
    ╚══ Grandchild 2.2
```

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

### Combining Widgets Example

Source: https://spectreconsole.net/console/live/live-display

Example demonstrating how to combine multiple widgets into layouts for a sophisticated dashboard.

```APIDOC
## Combining Widgets

Create sophisticated dashboards by combining multiple widgets in layouts.

```csharp
// Create status table
var statusTable = new Table()
    .Border(TableBorder.Rounded)
    .BorderColor(Color.Cyan)
    .AddColumn("Service")
    .AddColumn("Status")
    .AddColumn("Requests/sec");
  
// Create metrics table
var metricsTable = new Table()
    .Border(TableBorder.Rounded)
    .BorderColor(Color.Yellow)
    .AddColumn("Metric")
    .AddColumn("Current")
    .AddColumn("Average");
  
// Create layout with both tables
var layout = new Layout("Root")
    .SplitRows(
        new Layout("Header"),
        new Layout("Body").SplitColumns(
            new Layout("Status"),
            new Layout("Metrics")
        )
    );
  
layout["Header"].Update(
    new Panel("[bold cyan]Real-Time Dashboard[/]")
        .BorderColor(Color.Blue)
        .Padding(1, 0)
);
  
layout["Status"].Update(new Panel(statusTable).Header("Services"));
layout["Metrics"].Update(new Panel(metricsTable).Header("System Metrics"));
  
AnsiConsole.Live(layout)
    .Start(ctx =>
    {
        for (int i = 0; i < 15; i++)
        {
            // Update status table
            statusTable.Rows.Clear();
            statusTable.AddRow("API Gateway", "[green]Healthy[/]", $"{Random.Shared.Next(100, 500)}");
            statusTable.AddRow("Auth Service", "[green]Healthy[/]", $"{Random.Shared.Next(50, 200)}");
            statusTable.AddRow("Database", i > 10 ? "[yellow]Degraded[/]" : "[green]Healthy[/]", $"{Random.Shared.Next(200, 800)}");
            statusTable.AddRow("Cache", "[green]Healthy[/]", $"{Random.Shared.Next(1000, 3000)}");
  
            // Update metrics table
            metricsTable.Rows.Clear();
            metricsTable.AddRow("CPU", $"{Random.Shared.Next(20, 75)}%", "45%");
            metricsTable.AddRow("Memory", $"{Random.Shared.Next(4, 12)} GB", "8 GB");
            metricsTable.AddRow("Disk I/O", $"{Random.Shared.Next(10, 90)} MB/s", "45 MB/s");
            metricsTable.AddRow("Network", $"{Random.Shared.Next(100, 500)} MB/s", "250 MB/s");
  
            ctx.Refresh();
            Thread.Sleep(1000);
        }
    });
```
```

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

### TreeGuide.BoldLine Example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Renders a tree structure using the BoldLine tree guide. This guide uses bold Unicode box-drawing characters.

```text
Root
┣━━ Child 1
┃   ┣━━ Grandchild 1.1
┃   ┗━━ Grandchild 1.2
┗━━ Child 2
    ┣━━ Grandchild 2.1
    ┗━━ Grandchild 2.2
```

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

### Configure CommandApp Entry Point

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Sets up the main entry point for the CLI application, configuring it to use the `GreetCommand`. This is the minimal setup to run the command.

```csharp
using Spectre.Console.Cli;
  
var app = new CommandApp<GreetCommand>();
return app.Run(args);
```

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

### Start Tasks Programmatically with Spectre.Console Progress

Source: https://spectreconsole.net/console/tutorials/progress-bars-tutorial

This snippet demonstrates how to start tasks programmatically within a progress bar. It shows how to set custom styles for completed, finished, and remaining portions of the bar, and how to control the start of a task based on the progress of another. Use this when you need to manage task dependencies or delay the start of certain operations.

```csharp
AnsiConsole.Progress()
    .Columns(
        new SpinnerColumn(),
        new TaskDescriptionColumn(),
        new ProgressBarColumn
        {
            CompletedStyle = new Style(Color.Green),
            FinishedStyle = new Style(Color.Lime),
            RemainingStyle = new Style(Color.Grey)
        },
        new PercentageColumn(),
        new ElapsedTimeColumn())
    .Start(ctx =>
    {
        var worldMap = ctx.AddTask("Loading World Map", maxValue: 200);
        var character = ctx.AddTask("Loading Character Data");
        var sounds = ctx.AddTask("Loading Sound Effects", maxValue: 50);
        // Textures won't start until we call StartTask()
        var textures = ctx.AddTask("Loading Textures", autoStart: false); 
  
        var random = new Random(42);
        while (!ctx.IsFinished)
        {
            worldMap.Increment(random.NextDouble() * 3);
            character.Increment(random.NextDouble() * 1.5);
            sounds.Increment(random.NextDouble() * 1.5);
  
            // Start textures once world map reaches 25%
            if (worldMap.Percentage >= 25 &&! textures.IsStarted) 
            {
                textures.StartTask(); 
            } 
  
            if (textures.IsStarted) 
            {
                textures.Increment(random.NextDouble() * 2); 
            } 
  
            Thread.Sleep(50);
        }
    });
  
AnsiConsole.MarkupLine("[lime]All assets loaded![/]");
```

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

### Example Command Line Usage

Source: https://spectreconsole.net/cli/how-to/using-custom-type-converters

Demonstrates how users can provide complex types like points on the command line using the defined options and custom converters.

```bash
myapp --point 10,20 --color red
myapp --point 100,200 --offset 5,5
```

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

### Wire Up CommandApp in Program.cs

Source: https://spectreconsole.net/cli

Configures and runs a Spectre.Console.Cli command application. This example sets GreetCommand as the root command.

```csharp
var app = new CommandApp<GreetCommand>();
return app.Run(args);

```

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

### Set Application Name and Add Usage Examples

Source: https://spectreconsole.net/cli/how-to/customizing-help-text-and-usage

Customize the application name and add common invocation patterns to the help text. This overrides the default executable name and provides clear examples for users.

```csharp
var app = new CommandApp<DeployCommand>();
  
app.Configure(config =>
{
    // Set application name (overrides default exe/dll name)
    config.SetApplicationName("myapp");
  
    // Set version shown in --version output
    config.SetApplicationVersion("1.2.0");
  
    // Add examples shown in top-level help
    config.AddExample("production");
    config.AddExample("staging", "--force");
    config.AddExample("dev", "--dry-run", "--verbose");
});
  
return await app.RunAsync(args);
```

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

### Basic Grid Usage

Source: https://spectreconsole.net/console/widgets/grid

Demonstrates the fundamental setup of a Grid by adding columns and then populating rows with content. Ensure each row has the same number of cells as there are columns.

```csharp
var grid = new Grid();
  
// Add columns
grid.AddColumn();
grid.AddColumn();
  
// Add rows
grid.AddRow("Name:", "[blue]John Doe[/]");
grid.AddRow("Email:", "[blue]john.doe@example.com[/]");
grid.AddRow("Phone:", "[blue]+1 (555) 123-4567[/]");
  
AnsiConsole.Write(grid);
```

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

### Register Commands with Metadata

Source: https://spectreconsole.net/cli/how-to/configuring-commandapp-and-commands

Register commands with descriptions, aliases, and examples using CommandApp.Configure. Includes conditional debug settings for exception propagation and example validation.

```csharp
var app = new CommandApp();
  
app.Configure(config =>
{
    // Set application identity for help output
    config.SetApplicationName("myapp");
    config.SetApplicationVersion("1.0.0");
  
    // Add commands with descriptions, aliases, and examples
    config.AddCommand<AddCommand>("add")
        .WithDescription("Add a new item")
        .WithAlias("a")
        .WithExample("add", "todo.txt")
        .WithExample("add", "notes.md", "--force");
  
    config.AddCommand<RemoveCommand>("remove")
        .WithDescription("Remove an item")
        .WithAlias("rm")
        .WithAlias("delete")
        .WithExample("remove", "old-file.txt");
  
    config.AddCommand<ListCommand>("list")
        .WithDescription("List all items")
        .WithAlias("ls");
  
#if DEBUG
    // Development-only settings
    config.PropagateExceptions();
    config.ValidateExamples();
#endif
});
  
return await app.RunAsync(args);
```

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

### Three-Column Layout Example

Source: https://spectreconsole.net/console/widgets/layout

Illustrates creating a standard application layout with navigation, main content, and sidebar regions.

```APIDOC
## Three-Column Layout

Create a classic application layout with navigation, main content, and sidebar regions containing different widget types.

### Method
```csharp
// Example usage of Layout for a three-column structure
var layout = new Layout("Root")
    .SplitColumns(
        new Layout("Navigation").Size(18),
        new Layout("Main"),
        new Layout("Sidebar").Size(22));
  
layout["Navigation"].Update(
    new Panel(new Markup(
        "[blue]Menu[/]\n" +
        "├─ Dashboard\n" +
        "├─ Reports\n" +
        "└─ Settings"))
        .BorderColor(Color.Blue));
  
var table = new Table()
    .BorderColor(Color.Green)
    .AddColumn("Item")
    .AddColumn("Value")
    .AddRow("Orders", "1,234")
    .AddRow("Revenue", "$45,678");
  
layout["Main"].Update(
    new Panel(table)
        .Header("Statistics")
        .BorderColor(Color.Green));
  
layout["Sidebar"].Update(
    new Panel("[yellow]Quick Actions[/]\n• New Report\n• Export Data\n• Refresh")
        .BorderColor(Color.Yellow));
  
AnsiConsole.Write(layout);
```
```

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

### Add Logging Packages

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Installs the necessary Microsoft.Extensions.Logging packages for structured logging.

```bash
dotnet add package Microsoft.Extensions.Logging
dotnet add package Microsoft.Extensions.Logging.Console
dotnet add package Microsoft.Extensions.DependencyInjection
```

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

### Using Line Tree Guide (Default)

Source: https://spectreconsole.net/console/widgets/tree

Sets the tree to use the default Unicode line drawing characters for its guide lines, suitable for most modern terminals.

```csharp
var tree = new Tree("Root")
    .Guide(TreeGuide.Line);
  
var child1 = tree.AddNode("Child 1");
child1.AddNode("Grandchild 1.1");
child1.AddNode("Grandchild 1.2");
  
var child2 = tree.AddNode("Child 2");
child2.AddNode("Grandchild 2.1");
  
AnsiConsole.Write(tree);
```

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

### Example Usage: Title Screens

Source: https://spectreconsole.net/console/widgets/align

Demonstrates how to use the Align class to center application splash screens or welcome messages.

```APIDOC
## Title Screens Example

### Description
Use centered alignment for application splash screens or welcome messages.

### Code
```csharp
var title = new FigletText("Spectre")
    .Color(Color.Blue);
  
var subtitle = new Markup("[italic grey]A modern .NET console library[/]");
  
var titleAligned = Align.Center(title);
var subtitleAligned = Align.Center(subtitle);
  
AnsiConsole.Write(titleAligned);
AnsiConsole.Write(subtitleAligned);
AnsiConsole.WriteLine();
  
var instructions = new Markup("[dim]Press any key to continue...[/]");
AnsiConsole.Write(Align.Center(instructions));
```
```

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

### LiveDisplay Methods

Source: https://spectreconsole.net/console/live/live-display

Methods for starting and managing the live display.

```APIDOC
### Methods

`Start(Action<LiveDisplayContext> action)`

Starts the live display.

### Parameters
- **action** (Action<LiveDisplayContext>) - The action to execute.

`T Start(Func<LiveDisplayContext, T> func)`

### Parameters
- **func** (Func<LiveDisplayContext, T>)

`Task StartAsync(Func<LiveDisplayContext, Task> func)`

Starts the live display.

### Parameters
- **func** (Func<LiveDisplayContext, Task>) - The action to execute.

### Returns
- The result.

`Task<T> StartAsync(Func<LiveDisplayContext, Task<T>> func)`

### Parameters
- **func** (Func<LiveDisplayContext, Task<T>>)
```

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

### Dynamic Visibility Example

Source: https://spectreconsole.net/console/widgets/layout

Shows how to control the visibility of layout sections at runtime.

```APIDOC
## Dynamic Visibility

Control section visibility at runtime to show or hide regions based on application state.

### Method
```csharp
// Example of controlling layout visibility
var layout = new Layout("Root")
    .SplitColumns(
        new Layout("Left"),
        new Layout("Middle"),
        new Layout("Right"));
  
layout["Left"].Update(new Panel("Always visible").BorderColor(Color.Green));
layout["Middle"].Update(new Panel("Hidden section").BorderColor(Color.Red));
layout["Right"].Update(new Panel("Also visible").BorderColor(Color.Blue));
  
// Hide the middle section
layout["Middle"].IsVisible = false;
  
AnsiConsole.Write(layout);
```
```

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

### Dashboard Layout Example

Source: https://spectreconsole.net/console/widgets/layout

Demonstrates how to create a dashboard layout with headers, footers, and split content areas using rows and columns.

```APIDOC
## Dashboard Layout

Combine multiple layout techniques to create a complete dashboard with headers, sidebars, content areas, and status bars.

### Method
```csharp
// Example usage of Layout for dashboard
var layout = new Layout("Root")
    .SplitRows(
        new Layout("Header").Size(3),
        new Layout("Main"),
        new Layout("Footer").Size(3));
  
layout["Header"].Update(
    new Panel("[bold yellow]System Dashboard[/]")
        .BorderColor(Color.Yellow));
  
layout["Main"].SplitColumns(
    new Layout("Left").Ratio(1),
    new Layout("Right").Ratio(2));
  
layout["Left"].SplitRows(
    new Layout("Metrics"),
    new Layout("Logs"));
  
layout["Metrics"].Update(
    new Panel("[green]CPU: 45%\nRAM: 62%\nDisk: 78%[/]")
        .Header("System Metrics")
        .BorderColor(Color.Green));
  
layout["Logs"].Update(
    new Panel("[dim]12:03 Process started\n12:05 Connected\n12:07 Ready[/]")
        .Header("Recent Logs")
        .BorderColor(Color.Blue));
  
layout["Right"].Update(
    new Panel("[white]Main application content area\nDisplays real-time data and visualizations[/]")
        .Header("Content")
        .BorderColor(Color.Cyan1));
  
layout["Footer"].Update(
    new Panel("[dim]Connected | Uptime: 2h 34m | Last Update: 12:07:45[/]")
        .BorderColor(Color.Grey));
  
AnsiConsole.Write(layout);
```
```

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

### Development Settings

Source: https://spectreconsole.net/cli/how-to/configuring-commandapp-and-commands

Enable development-specific settings like propagating exceptions for full stack traces and validating examples at startup.

```csharp
#if DEBUG
    config.PropagateExceptions();  // Get full stack traces
    config.ValidateExamples();     // Verify all WithExample calls are valid
#endif
```

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

### Greet Command Implementation

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

The main command class that uses the IGreetingFactory to get a greeting service and display the greeting. It depends on IGreetingFactory and IAnsiConsole.

```csharp
public class GreetCommand : Command<GreetCommand.Settings>
{
    private readonly IGreetingFactory _greetingFactory;
    private readonly IAnsiConsole _console;
  
    public GreetCommand(IGreetingFactory greetingFactory, IAnsiConsole console)
    {
        _greetingFactory = greetingFactory;
        _console = console;
    }
  
    public class Settings : CommandSettings
    {
        [CommandArgument(0, "<name>")]
        [Description("The name to greet")]
        public string Name { get; init; } = string.Empty;
  
        [CommandOption("-s|--style")]
        [Description("The greeting style to use (Casual, Formal, or Enthusiastic)")]
        [DefaultValue(GreetingStyle.Casual)]
        public GreetingStyle Style { get; init; }
    }
  
    protected override int Execute(CommandContext context, Settings settings, CancellationToken cancellation)
    {
        var service = _greetingFactory.Create();
        var greeting = service.GetGreeting(settings.Name);
        _console.WriteLine(greeting);
        return 0;
    }
}
```

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

### Run Add and List Commands

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Demonstrates how to execute the 'add' and 'list' commands from the .NET CLI.

```bash
dotnet run -- add Newtonsoft.Json
# Added package Newtonsoft.Json
  
dotnet run -- list
# Packages:
#   (none yet)
```

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

### Runtime Log Level Examples

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Demonstrates how to run the CLI application with different log levels specified via the --logLevel option. Observe the output changes based on the selected verbosity.

```bash
dotnet run -- myfile.txt
# info: Processing step 1...
  
dotnet run -- myfile.txt --logLevel Debug
# dbug: Detailed step 1 information
# info: Processing step 1...
  
dotnet run -- myfile.txt --logLevel Warning
# warn: This is a warning message
```

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

### Tree Extension Methods

Source: https://spectreconsole.net/console/widgets/tree

Offers extension methods for Tree widgets, including getting segments, setting guide lines, and applying styles.

```APIDOC
## Tree Extension Methods

### `IEnumerable<Segment> GetSegments(IAnsiConsole console)`
Gets the segments for a renderable using the specified console.

**Parameters:**
* `console` (IAnsiConsole) - The console.

**Returns:**
An enumerable containing segments representing the specified .

### `Tree Guide(TreeGuide guide)`
Sets the tree guide line appearance.

**Parameters:**
* `guide` (TreeGuide) - The tree guide lines to use.

**Returns:**
The same instance so that multiple calls can be chained.

### `Tree Style(Nullable<Style> style)`
Sets the tree style.

**Parameters:**
* `style` (Nullable<Style>) - The tree style.

**Returns:**
The same instance so that multiple calls can be chained.
```

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

### Get Result from Task with Spinner

Source: https://spectreconsole.net/console/how-to/running-tasks-with-async-spinner

Call `.Spinner()` on a `Task<T>` to display a spinner and retrieve the result of the asynchronous operation. The result can then be used, for example, with `AnsiConsole.MarkupLine`.

```csharp
var result = await FetchDataAsync().Spinner(Spinner.Known.Star);
AnsiConsole.MarkupLine($"[green]Got result: {result}[/]");
```

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

### Run Initial Application

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Executes the CLI application and shows the output without structured logging.

```bash
dotnet run -- myfile.txt
# Starting to process: myfile.txt
# Processing step 1...
# Processing step 2...
# Processing step 3...
# Processing complete!
```

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

### XmlDoc Output Format Example

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

An example of the XML output generated by the XmlDoc command, detailing command structure, parameters, and examples.

```xml
<?xml version="1.0" encoding="utf-8"?>
<Model>
  <Command Name="add" ClrType="AddCommand" Settings="AddSettings">
    <Description>Add a new item</Description>
    <Parameters>
      <Argument Name="name" Position="0" Required="true" Kind="Scalar" />
      <Option Short="v" Long="verbose" Required="false" Kind="Flag" />
    </Parameters>
    <Examples>
      <Example>add item --verbose</Example>
    </Examples>
  </Command>
</Model>
```

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

### Run Basic Greeting Command

Source: https://spectreconsole.net/cli/tutorials/quick-start-your-first-cli-app

Executes the 'GreetingApp' with a provided name argument. Demonstrates the required argument handling.

```bash
dotnet run -- Alice

```

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

### Basic Status Display Usage

Source: https://spectreconsole.net/console/live/status

Demonstrates the fundamental way to start a status display with a message and a callback for work simulation.

```csharp
AnsiConsole.Status()
    .Start("Processing data...", ctx =>
    {
        // Simulate work
        Thread.Sleep(3000);
  
        AnsiConsole.MarkupLine("[green]Processing complete![/]");
    });
```

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

### Create New Console Project and Add Spectre.Console.Cli

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Initializes a new .NET console project and adds the necessary Spectre.Console.Cli package.

```bash
dotnet new console -n PackageManager
cd PackageManager
dotnet add package Spectre.Console.Cli
```

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

### Install Spectre.Console.ImageSharp

Source: https://spectreconsole.net/console/widgets/canvas-image

The CanvasImage widget is not included in the default Spectre.Console package and must be installed separately.

```bash
dotnet add package Spectre.Console.ImageSharp

```

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

### Add Spectre.Console.Cli Package

Source: https://spectreconsole.net/cli/tutorials/quick-start-your-first-cli-app

Installs the Spectre.Console.Cli package to your .NET project. Ensure you have .NET 6.0 or later installed.

```bash
dotnet new console -n GreetingApp
cd GreetingApp
dotnet add package Spectre.Console.Cli

```

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

### Returning Values from Live Display

Source: https://spectreconsole.net/console/live/live-display

Use the generic `Start<T>()` method to return a value from the live display context. The method's return value is captured and can be used after the live display completes.

```csharp
var result = AnsiConsole.Live(new Text("Processing..."))
    .Start(ctx =>
    {
        int total = 0;
  
        for (int i = 1; i <= 10; i++)
        {
            total += i;
            ctx.UpdateTarget(new Text($"Processing: {i}/10 (Total: {total})"));
            Thread.Sleep(300);
        }
  
        ctx.UpdateTarget(new Text("[green]Complete![/]"));
        Thread.Sleep(500);
  
        return total;
    });
  
AnsiConsole.WriteLine($"Final result: {result}");
```

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

### Get Segments for a Renderable

Source: https://spectreconsole.net/console/widgets/padder

Gets the segments for a renderable using the specified console. This method is useful for custom rendering logic.

```csharp
IEnumerable<Segment> GetSegments(IAnsiConsole console)
```

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

### Create a Basic Table

Source: https://spectreconsole.net/console/how-to/displaying-tabular-data

Use the `Table` class to create a table by adding columns and then rows. Finally, write the table to the console.

```csharp
var table = new Table();
  
table.AddColumn("Name");
table.AddColumn("Department");
table.AddColumn("Sales");
  
table.AddRow("Alice", "North", "$12,400");
table.AddRow("Bob", "South", "$8,750");
table.AddRow("Carol", "West", "$15,200");
  
AnsiConsole.Write(table);
```

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

### Using DoubleLine Tree Guide

Source: https://spectreconsole.net/console/widgets/tree

Configures the tree to use double-line Unicode characters for its guide lines, resulting in a more prominent visual appearance.

```csharp
var tree = new Tree("Root")
    .Guide(TreeGuide.DoubleLine);
  
var child1 = tree.AddNode("Child 1");
child1.AddNode("Grandchild 1.1");
  
var child2 = tree.AddNode("Child 2");
child2.AddNode("Grandchild 2.1");
  
AnsiConsole.Write(tree);
```

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

### Using BoldLine Tree Guide

Source: https://spectreconsole.net/console/widgets/tree

Sets the tree to use bold Unicode characters for its guide lines, making them stand out more in dense tree structures.

```csharp
var tree = new Tree("Root")
    .Guide(TreeGuide.BoldLine);
  
var child1 = tree.AddNode("Child 1");
child1.AddNode("Grandchild 1.1");
  
var child2 = tree.AddNode("Child 2");
child2.AddNode("Grandchild 2.1");
  
AnsiConsole.Write(tree);
```

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

### Using Ascii Tree Guide

Source: https://spectreconsole.net/console/widgets/tree

Configures the tree to use ASCII characters for its guide lines, providing maximum compatibility with terminals that do not support Unicode.

```csharp
var tree = new Tree("Root")
    .Guide(TreeGuide.Ascii);
  
var child1 = tree.AddNode("Child 1");
child1.AddNode("Grandchild 1.1");
child1.AddNode("Grandchild 1.2");
  
var child2 = tree.AddNode("Child 2");
child2.AddNode("Grandchild 2.1");
  
AnsiConsole.Write(tree);
```

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

### Basic Tree Creation

Source: https://spectreconsole.net/console/widgets/tree

Demonstrates how to create a simple tree with a root and a few child nodes. Use `AddNode()` to add children and chain further nodes.

```csharp
var tree = new Tree("Project Files");
  
var src = tree.AddNode("src");
src.AddNode("Program.cs");
src.AddNode("Config.cs");
  
var docs = tree.AddNode("docs");
docs.AddNode("README.md");
docs.AddNode("API.md");
  
AnsiConsole.Write(tree);
```

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

### Basic Table Usage

Source: https://spectreconsole.net/console/widgets/table

Demonstrates the fundamental process of creating a table by adding columns and then rows. Ensure each row has the same number of cells as there are columns.

```csharp
var table = new Table();
  
// Add columns
table.AddColumn("Name");
table.AddColumn("Age");
table.AddColumn("City");
  
// Add rows
table.AddRow("Alice", "28", "New York");
table.AddRow("Bob", "35", "London");
table.AddRow("Charlie", "42", "Tokyo");
  
AnsiConsole.Write(table);
```

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

### Configure Logging in Entry Point

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Configures the service collection to include console logging with a minimum level of Information and sets up the command application with the custom registrar.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Spectre.Console.Cli;
  
var services = new ServiceCollection();
services.AddLogging(builder =>
{
    builder.AddConsole();
    builder.SetMinimumLevel(LogLevel.Information);
});
  
var registrar = new TypeRegistrar(services);
var app = new CommandApp<ProcessCommand>(registrar);
return app.Run(args);
```

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

### Proportional Sizing with Ratios

Source: https://spectreconsole.net/console/widgets/layout

Shows how to distribute space proportionally among layout sections using `Ratio()`. Sections with higher ratios will receive a larger share of the available space.

```csharp
var layout = new Layout("Root")
    .SplitColumns(
        new Layout("Left").Ratio(1),
        new Layout("Center").Ratio(2),
        new Layout("Right").Ratio(1));
  
layout["Left"].Update(new Panel("1/4 width").BorderColor(Color.Blue));
layout["Center"].Update(new Panel("2/4 width (half)").BorderColor(Color.Green));
layout["Right"].Update(new Panel("1/4 width").BorderColor(Color.Yellow));
  
AnsiConsole.Write(layout);
```

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

### Style Tree Nodes and Guides

Source: https://spectreconsole.net/console/how-to/displaying-hierarchical-data

Apply styling to tree nodes using markup and change the line style of the tree guide. The `Style.Parse()` method is used for styling.

```csharp
var tree = new Tree("[yellow]MyProject[/]")
    .Guide(TreeGuide.BoldLine)
    .Style(Style.Parse("dim"));
  
var src = tree.AddNode("[blue]src[/]");
src.AddNode("[grey]Program.cs[/]");
src.AddNode("[grey]Startup.cs[/]");
  
var controllers = src.AddNode("[blue]Controllers[/]");
controllers.AddNode("[grey]HomeController.cs[/]");
controllers.AddNode("[grey]ApiController.cs[/]");
  
var tests = tree.AddNode("[green]tests[/]");
tests.AddNode("[grey]UnitTests.cs[/]");
  
AnsiConsole.Write(tree);
```

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

### Set Culture for French (Monday Start)

Source: https://spectreconsole.net/console/widgets/calendar

Configure the calendar to use French culture settings, which defaults to Monday as the start of the week and uses fr-FR formatting for day and month names.

```csharp
AnsiConsole.MarkupLine("[yellow]French culture (Monday start):[/]");
var frenchCulture = new Calendar(2025, 11)
{
    Culture = new CultureInfo("fr-FR")
};
frenchCulture.AddCalendarEvent(2025, 11, 15);
AnsiConsole.Write(frenchCulture);
```

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

### Create New Console Project

Source: https://spectreconsole.net/console/tutorials/getting-started-building-rich-console-app

Use the dotnet CLI to create a new console application. Navigate into the project directory.

```bash
dotnet new console -n MySpectreApp
cd MySpectreApp
```

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

### Access Version Command

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Demonstrates the different ways to access the version command to display library versions. The global option requires ApplicationVersion to be configured.

```bash
myapp cli version
myapp --version
myapp -v
```

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

### Set Culture for US (Sunday Start)

Source: https://spectreconsole.net/console/widgets/calendar

Configure the calendar to use US culture settings, which defaults to Sunday as the start of the week and uses en-US formatting for day and month names.

```csharp
AnsiConsole.MarkupLine("[yellow]US culture (Sunday start):[/]");
var usCulture = new Calendar(2025, 11)
{
    Culture = new CultureInfo("en-US")
};
usCulture.AddCalendarEvent(2025, 11, 15);
AnsiConsole.Write(usCulture);
```

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

### Basic Grid with Panels

Source: https://spectreconsole.net/console/widgets/grid

Demonstrates how to create a simple grid with two columns and embed Panel widgets within its rows. Useful for basic side-by-side content.

```csharp
var grid = new Grid();
  
grid.AddColumn();
grid.AddColumn();
  
var leftPanel = new Panel("[yellow]Configuration[/]")
    .BorderColor(Color.Yellow)
    .RoundedBorder();
  
var rightPanel = new Panel("[green]Status: Active[/]")
    .BorderColor(Color.Green)
    .RoundedBorder();
  
grid.AddRow(leftPanel, rightPanel);
  
AnsiConsole.Write(grid);
```

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

### Complete Image Configuration with Resampling and Cropping

Source: https://spectreconsole.net/console/widgets/canvas-image

Configure image appearance completely by combining sizing, resampling, and mutations. This example sets the max width, applies bicubic resampling, and crops the image.

```csharp
var image = new CanvasImage("path/to/image.png")
    .MaxWidth(80)
    .BicubicResampler()
    .Mutate(ctx => ctx.Crop(new Rectangle(10, 10, 200, 200)));
  
AnsiConsole.Write(image);
```

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

### BoxBorder.Near Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.Near style.

```text
 ▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁ 
▕ This is a sample panel       ▏
▕ with multiple lines of       ▏
▕ content inside the box.      ▏
 ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔ 
```

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

### Create New Console Project

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Initializes a new .NET console application and adds the Spectre.Console.Cli package.

```bash
dotnet new console -n LoggingApp
cd LoggingApp
dotnet add package Spectre.Console.Cli
```

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

### BoxBorder.McGuganVertical Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.McGuganVertical style.

```text
▕▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▏
▕ This is a sample panel       ▏
▕ with multiple lines of       ▏
▕ content inside the box.      ▏
▕▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▏
```

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

### BoxBorder.McGuganHorizontal Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.McGuganHorizontal style.

```text
▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
▏ This is a sample panel       ▕
▏ with multiple lines of       ▕
▏ content inside the box.      ▕
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
```

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

### Run Hierarchical Commands

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Demonstrates executing the hierarchical 'add package' and 'add reference' commands.

```bash
dotnet run -- add package Newtonsoft.Json
# Added package Newtonsoft.Json
  
dotnet run -- add reference ../MyLib/MyLib.csproj
# Added reference to ../MyLib/MyLib.csproj
  
dotnet run -- add --help
```

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

### Implement a Custom Help Provider

Source: https://spectreconsole.net/cli/how-to/customizing-help-text-and-usage

Register a custom help provider by implementing `IHelpProvider` for complete control over help formatting. This allows restructuring sections or adding custom content.

```csharp
app.Configure(config =>
{
    config.SetHelpProvider(new CustomHelpProvider(config.Settings));
});
```

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

### BoxBorder.HeavyVertical Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.HeavyVertical style.

```text
┎──────────────────────────────┒
┃ This is a sample panel       ┃
┃ with multiple lines of       ┃
┃ content inside the box.      ┃
┖──────────────────────────────┚
```

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

### BoxBorder.HeavyHorizontal Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.HeavyHorizontal style.

```text
┍━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑
│ This is a sample panel       │
│ with multiple lines of       │
│ content inside the box.      │
┕━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┙
```

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

### BoxBorder.HeavyDotted Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.HeavyDotted style.

```text
┏┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┓
┋ This is a sample panel       ┋
┋ with multiple lines of       ┋
┋ content inside the box.      ┋
┗┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┉┛
```

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

### Live Rendering with Progress Bar

Source: https://spectreconsole.net/console/explanation/understanding-rendering-model

Demonstrates how to use `AnsiConsole.Progress()` to create live-updating progress displays. Ensure `StartAsync` is awaited and tasks are managed within the provided context.

```csharp
await AnsiConsole.Progress()
    .StartAsync(async ctx =>
    {
        var task = ctx.AddTask("Processing");
        while (!task.IsFinished)
        {
            task.Increment(1);
            await Task.Delay(50);
        }
    });
```

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

### BoxBorder.HeavyDashedWide Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.HeavyDashedWide style.

```text
┏╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍┓
╏ This is a sample panel       ╏
╏ with multiple lines of       ╏
╏ content inside the box.      ╏
┗╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍┛
```

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

### Running CLI with Verbose Flag

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Demonstrates how to execute the CLI with the `--verbose` flag, showing the detailed output generated by the 'add package' command. This confirms that shared settings are correctly applied.

```bash
dotnet run -- add package Serilog --version 3.0.0 --verbose
# Searching for package Serilog...
# Resolving version 3.0.0...
# Installing to ./packages...
# Added package Serilog v3.0.0
```

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

### Basic Layout with Columns

Source: https://spectreconsole.net/console/widgets/layout

Demonstrates how to split a layout into two columns and update each section with a panel. Use this for simple side-by-side content.

```csharp
var layout = new Layout("Root")
    .SplitColumns(
        new Layout("Left"),
        new Layout("Right"));
  
layout["Left"].Update(
    new Panel("Left Panel")
        .BorderColor(Color.Green));
  
layout["Right"].Update(
    new Panel("Right Panel")
        .BorderColor(Color.Blue));
  
AnsiConsole.Write(layout);
```

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

### BoxBorder.HeavyDashed Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.HeavyDashed style.

```text
┏┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┓
┇ This is a sample panel       ┇
┇ with multiple lines of       ┇
┇ content inside the box.      ┇
┗┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┅┛
```

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

### Configure CommandApp with Add and List Commands

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Wires up the 'add' and 'list' commands to the CommandApp using the Configure method.

```csharp
using Spectre.Console.Cli;
  
var app = new CommandApp();
app.Configure(config =>
{
    config.AddCommand<AddCommand>("add");
    config.AddCommand<ListCommand>("list");
});
return app.Run(args);
```

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

### BoxBorder.Heavy Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.Heavy style.

```text
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ This is a sample panel       ┃
┃ with multiple lines of       ┃
┃ content inside the box.      ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
```

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

### BoxBorder.DoubleVertical Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.DoubleVertical style.

```text
╓──────────────────────────────╖
║ This is a sample panel       ║
║ with multiple lines of       ║
║ content inside the box.      ║
╙──────────────────────────────╜
```

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

### Complete Selection Prompt Example

Source: https://spectreconsole.net/console/prompts/selection-prompt

Demonstrates a comprehensive selection prompt with search, pagination, custom styling, and complex object handling. Requires a helper function GetPriorityColor.

```csharp
var projects = new[]
{
    new Project { Name = "E-Commerce Platform", Status = "Active", Priority = "High" },
    new Project { Name = "Mobile App Redesign", Status = "Active", Priority = "Medium" },
    new Project { Name = "API Gateway", Status = "Planning", Priority = "High" },
    new Project { Name = "Customer Portal", Status = "Active", Priority = "Low" },
    new Project { Name = "Analytics Dashboard", Status = "Completed", Priority = "Medium" },
    new Project { Name = "Payment Integration", Status = "Active", Priority = "High" },
    new Project { Name = "User Authentication", Status = "Completed", Priority = "High" },
    new Project { Name = "Email Service", Status = "Planning", Priority = "Low" }
};
  
var prompt = new SelectionPrompt<Project>()
    .Title("Select a [green]project[/] to view details")
    .PageSize(6)
    .MoreChoicesText("[grey](Move up and down to see more projects)[/]")
    .EnableSearch()
    .SearchPlaceholderText("Type to search projects...")
    .WrapAround()
    .HighlightStyle(new Style(Color.Cyan1, decoration: Decoration.Bold))
    .UseConverter(p => $"[bold]{p.Name}[/] - {p.Status} [{GetPriorityColor(p.Priority)}]{p.Priority}[/]")
    .AddChoices(projects);
  
prompt.SearchHighlightStyle = new Style(Color.Yellow, decoration: Decoration.Underline);
  
var selected = AnsiConsole.Prompt(prompt);
  
AnsiConsole.WriteLine();
AnsiConsole.Write(new Panel($"[bold]{selected.Name}[/]\nStatus: {selected.Status}\nPriority: {selected.Priority}")
    .Header("Project Details")
    .BorderColor(Color.Cyan1));
```

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

### Applying Tree-Wide Styling

Source: https://spectreconsole.net/console/widgets/tree

Demonstrates how to apply a consistent style to all tree guide lines using the `Style()` method. This ensures a cohesive visual theme for the entire tree.

```csharp
var tree = new Tree("Styled Tree")
    .Style(Style.Parse("blue bold"));
  
tree.AddNode("Item 1");
tree.AddNode("Item 2");
tree.AddNode("Item 3");
  
AnsiConsole.Write(tree);
```

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

### BoxBorder.DoubleHorizontal Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.DoubleHorizontal style.

```text
╒══════════════════════════════╕
│ This is a sample panel       │
│ with multiple lines of       │
│ content inside the box.      │
╘══════════════════════════════╛
```

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

### BoxBorder.Double Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.Double style.

```text
╔══════════════════════════════╗
║ This is a sample panel       ║
║ with multiple lines of       ║
║ content inside the box.      ║
╚══════════════════════════════╝
```

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

### BoxBorder.Dotted Example

Source: https://spectreconsole.net/console/reference/box-border-reference

Displays the visual representation of the BoxBorder.Dotted style.

```text
┌┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┐
┊ This is a sample panel       ┊
┊ with multiple lines of       ┊
┊ content inside the box.      ┊
└┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┘
```

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

### Configure DI Container and CommandApp

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Sets up the `ServiceCollection`, registers the `GreetingService`, creates a `TypeRegistrar`, and initializes `CommandApp` with the registrar. This integrates the DI container with Spectre.Console.Cli.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Spectre.Console.Cli;
  
var services = new ServiceCollection();
services.AddSingleton<IGreetingService, GreetingService>();
  
var registrar = new TypeRegistrar(services);
var app = new CommandApp<GreetCommand>(registrar);
return app.Run(args);
```