Add autocomplete for text prompt

Closes #166

src/Spectre.Console/Widgets/Progress/Columns/PercentageColumn.cs

@@ -0,0 +1,35 @@
+using System;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A column showing task progress in percentage.
+    /// </summary>
+    public sealed class PercentageColumn : ProgressColumn
+    {
+        /// <summary>
+        /// Gets or sets the style for a non-complete task.
+        /// </summary>
+        public Style Style { get; set; } = Style.Plain;
+
+        /// <summary>
+        /// Gets or sets the style for a completed task.
+        /// </summary>
+        public Style CompletedStyle { get; set; } = new Style(foreground: Color.Green);
+
+        /// <inheritdoc/>
+        public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
+        {
+            var percentage = (int)task.Percentage;
+            var style = percentage == 100 ? CompletedStyle : Style ?? Style.Plain;
+            return new Text($"{percentage}%", style).RightAligned();
+        }
+
+        /// <inheritdoc/>
+        public override int? GetColumnWidth(RenderContext context)
+        {
+            return 4;
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Columns/ProgressBarColumn.cs

@@ -0,0 +1,45 @@
+using System;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A column showing task progress as a progress bar.
+    /// </summary>
+    public sealed class ProgressBarColumn : ProgressColumn
+    {
+        /// <summary>
+        /// Gets or sets the width of the column.
+        /// </summary>
+        public int? Width { get; set; } = 40;
+
+        /// <summary>
+        /// Gets or sets the style of completed portions of the progress bar.
+        /// </summary>
+        public Style CompletedStyle { get; set; } = new Style(foreground: Color.Yellow);
+
+        /// <summary>
+        /// Gets or sets the style of a finished progress bar.
+        /// </summary>
+        public Style FinishedStyle { get; set; } = new Style(foreground: Color.Green);
+
+        /// <summary>
+        /// Gets or sets the style of remaining portions of the progress bar.
+        /// </summary>
+        public Style RemainingStyle { get; set; } = new Style(foreground: Color.Grey);
+
+        /// <inheritdoc/>
+        public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
+        {
+            return new ProgressBar
+            {
+                MaxValue = task.MaxValue,
+                Value = task.Value,
+                Width = Width,
+                CompletedStyle = CompletedStyle,
+                FinishedStyle = FinishedStyle,
+                RemainingStyle = RemainingStyle,
+            };
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Columns/RemainingTimeColumn.cs

@@ -0,0 +1,37 @@
+using System;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A column showing the remaining time of a task.
+    /// </summary>
+    public sealed class RemainingTimeColumn : ProgressColumn
+    {
+        /// <inheritdoc/>
+        protected internal override bool NoWrap => true;
+
+        /// <summary>
+        /// Gets or sets the style of the remaining time text.
+        /// </summary>
+        public Style Style { get; set; } = new Style(foreground: Color.Blue);
+
+        /// <inheritdoc/>
+        public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
+        {
+            var remaining = task.RemainingTime;
+            if (remaining == null)
+            {
+                return new Markup("-:--:--");
+            }
+
+            return new Text($"{remaining.Value:h\\:mm\\:ss}", Style ?? Style.Plain);
+        }
+
+        /// <inheritdoc/>
+        public override int? GetColumnWidth(RenderContext context)
+        {
+            return 7;
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Columns/SpinnerColumn.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Linq;
+using Spectre.Console.Internal;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A column showing a spinner.
+    /// </summary>
+    public sealed class SpinnerColumn : ProgressColumn
+    {
+        private const string ACCUMULATED = "SPINNER_ACCUMULATED";
+        private const string INDEX = "SPINNER_INDEX";
+
+        private readonly object _lock;
+        private Spinner _spinner;
+        private int? _maxWidth;
+
+        /// <inheritdoc/>
+        protected internal override bool NoWrap => true;
+
+        /// <summary>
+        /// Gets or sets the <see cref="Console.Spinner"/>.
+        /// </summary>
+        public Spinner Spinner
+        {
+            get => _spinner;
+            set
+            {
+                lock (_lock)
+                {
+                    _spinner = value ?? Spinner.Known.Default;
+                    _maxWidth = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the style of the spinner.
+        /// </summary>
+        public Style? Style { get; set; } = new Style(foreground: Color.Yellow);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpinnerColumn"/> class.
+        /// </summary>
+        public SpinnerColumn()
+            : this(Spinner.Known.Default)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SpinnerColumn"/> class.
+        /// </summary>
+        /// <param name="spinner">The spinner to use.</param>
+        public SpinnerColumn(Spinner spinner)
+        {
+            _spinner = spinner ?? throw new ArgumentNullException(nameof(spinner));
+            _lock = new object();
+        }
+
+        /// <inheritdoc/>
+        public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
+        {
+            var useAscii = (context.LegacyConsole || !context.Unicode) && _spinner.IsUnicode;
+            var spinner = useAscii ? Spinner.Known.Ascii : _spinner ?? Spinner.Known.Default;
+
+            if (!task.IsStarted || task.IsFinished)
+            {
+                return new Markup(new string(' ', GetMaxWidth(context)));
+            }
+
+            var accumulated = task.State.Update<double>(ACCUMULATED, acc => acc + deltaTime.TotalMilliseconds);
+            if (accumulated >= spinner.Interval.TotalMilliseconds)
+            {
+                task.State.Update<double>(ACCUMULATED, _ => 0);
+                task.State.Update<int>(INDEX, index => index + 1);
+            }
+
+            var index = task.State.Get<int>(INDEX);
+            var frame = spinner.Frames[index % spinner.Frames.Count];
+            return new Markup(frame.EscapeMarkup(), Style ?? Style.Plain);
+        }
+
+        /// <inheritdoc/>
+        public override int? GetColumnWidth(RenderContext context)
+        {
+            return GetMaxWidth(context);
+        }
+
+        private int GetMaxWidth(RenderContext context)
+        {
+            lock (_lock)
+            {
+                if (_maxWidth == null)
+                {
+                    var useAscii = (context.LegacyConsole || !context.Unicode) && _spinner.IsUnicode;
+                    var spinner = useAscii ? Spinner.Known.Ascii : _spinner ?? Spinner.Known.Default;
+
+                    _maxWidth = spinner.Frames.Max(frame => Cell.GetCellLength(context, frame));
+                }
+
+                return _maxWidth.Value;
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Columns/TaskDescriptionColumn.cs

@@ -0,0 +1,21 @@
+using System;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A column showing the task description.
+    /// </summary>
+    public sealed class TaskDescriptionColumn : ProgressColumn
+    {
+        /// <inheritdoc/>
+        protected internal override bool NoWrap => true;
+
+        /// <inheritdoc/>
+        public override IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime)
+        {
+            var text = task.Description?.RemoveNewLines()?.Trim();
+            return new Markup(text ?? string.Empty).Overflow(Overflow.Ellipsis).RightAligned();
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Progress.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Spectre.Console.Internal;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a task list.
+    /// </summary>
+    public sealed class Progress
+    {
+        private readonly IAnsiConsole _console;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not task list should auto refresh.
+        /// Defaults to <c>true</c>.
+        /// </summary>
+        public bool AutoRefresh { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not the task list should
+        /// be cleared once it completes.
+        /// Defaults to <c>false</c>.
+        /// </summary>
+        public bool AutoClear { get; set; }
+
+        /// <summary>
+        /// Gets or sets the refresh rate if <c>AutoRefresh</c> is enabled.
+        /// Defaults to 10 times/second.
+        /// </summary>
+        public TimeSpan RefreshRate { get; set; } = TimeSpan.FromMilliseconds(100);
+
+        internal List<ProgressColumn> Columns { get; }
+
+        internal ProgressRenderer? FallbackRenderer { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Progress"/> class.
+        /// </summary>
+        /// <param name="console">The console to render to.</param>
+        public Progress(IAnsiConsole console)
+        {
+            _console = console ?? throw new ArgumentNullException(nameof(console));
+
+            // Initialize with default columns
+            Columns = new List<ProgressColumn>
+            {
+                new TaskDescriptionColumn(),
+                new ProgressBarColumn(),
+                new PercentageColumn(),
+            };
+        }
+
+        /// <summary>
+        /// Starts the progress task list.
+        /// </summary>
+        /// <param name="action">The action to execute.</param>
+        public void Start(Action<ProgressContext> action)
+        {
+            var task = StartAsync(ctx =>
+            {
+                action(ctx);
+                return Task.CompletedTask;
+            });
+
+            task.GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Starts the progress task list.
+        /// </summary>
+        /// <param name="action">The action to execute.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public async Task StartAsync(Func<ProgressContext, Task> action)
+        {
+            if (action is null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var renderer = CreateRenderer();
+            renderer.Started();
+
+            try
+            {
+                using (new RenderHookScope(_console, renderer))
+                {
+                    var context = new ProgressContext(_console, renderer);
+
+                    if (AutoRefresh)
+                    {
+                        using (var thread = new ProgressRefreshThread(context, renderer.RefreshRate))
+                        {
+                            await action(context).ConfigureAwait(false);
+                        }
+                    }
+                    else
+                    {
+                        await action(context).ConfigureAwait(false);
+                    }
+
+                    context.Refresh();
+                }
+            }
+            finally
+            {
+                renderer.Completed(AutoClear);
+            }
+        }
+
+        private ProgressRenderer CreateRenderer()
+        {
+            var caps = _console.Capabilities;
+            var interactive = caps.SupportsInteraction && caps.SupportsAnsi;
+
+            if (interactive)
+            {
+                var columns = new List<ProgressColumn>(Columns);
+                return new DefaultProgressRenderer(_console, columns, RefreshRate);
+            }
+            else
+            {
+                return FallbackRenderer ?? new FallbackProgressRenderer();
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressColumn.cs

@@ -0,0 +1,35 @@
+using System;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a progress column.
+    /// </summary>
+    public abstract class ProgressColumn
+    {
+        /// <summary>
+        /// Gets a value indicating whether or not content should not wrap.
+        /// </summary>
+        protected internal virtual bool NoWrap { get; }
+
+        /// <summary>
+        /// Gets a renderable representing the column.
+        /// </summary>
+        /// <param name="context">The render context.</param>
+        /// <param name="task">The task.</param>
+        /// <param name="deltaTime">The elapsed time since last call.</param>
+        /// <returns>A renderable representing the column.</returns>
+        public abstract IRenderable Render(RenderContext context, ProgressTask task, TimeSpan deltaTime);
+
+        /// <summary>
+        /// Gets the width of the column.
+        /// </summary>
+        /// <param name="context">The context.</param>
+        /// <returns>The width of the column, or <c>null</c> to calculate.</returns>
+        public virtual int? GetColumnWidth(RenderContext context)
+        {
+            return null;
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressContext.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Spectre.Console.Internal;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a context that can be used to interact with a <see cref="Progress"/>.
+    /// </summary>
+    public sealed class ProgressContext
+    {
+        private readonly List<ProgressTask> _tasks;
+        private readonly object _taskLock;
+        private readonly IAnsiConsole _console;
+        private readonly ProgressRenderer _renderer;
+        private int _taskId;
+
+        /// <summary>
+        /// Gets a value indicating whether or not all tasks have completed.
+        /// </summary>
+        public bool IsFinished => _tasks.All(task => task.IsFinished);
+
+        internal Encoding Encoding => _console.Encoding;
+
+        internal ProgressContext(IAnsiConsole console, ProgressRenderer renderer)
+        {
+            _tasks = new List<ProgressTask>();
+            _taskLock = new object();
+            _console = console ?? throw new ArgumentNullException(nameof(console));
+            _renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
+        }
+
+        /// <summary>
+        /// Adds a task.
+        /// </summary>
+        /// <param name="description">The task description.</param>
+        /// <param name="settings">The task settings.</param>
+        /// <returns>The task's ID.</returns>
+        public ProgressTask AddTask(string description, ProgressTaskSettings? settings = null)
+        {
+            lock (_taskLock)
+            {
+                settings ??= new ProgressTaskSettings();
+                var task = new ProgressTask(_taskId++, description, settings.MaxValue, settings.AutoStart);
+
+                _tasks.Add(task);
+                return task;
+            }
+        }
+
+        /// <summary>
+        /// Refreshes the current progress.
+        /// </summary>
+        public void Refresh()
+        {
+            _renderer.Update(this);
+            _console.Render(new ControlSequence(string.Empty));
+        }
+
+        internal IReadOnlyList<ProgressTask> GetTasks()
+        {
+            lock (_taskLock)
+            {
+                return new List<ProgressTask>(_tasks);
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressRefreshThread.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+
+namespace Spectre.Console.Internal
+{
+    internal sealed class ProgressRefreshThread : IDisposable
+    {
+        private readonly ProgressContext _context;
+        private readonly TimeSpan _refreshRate;
+        private readonly ManualResetEvent _running;
+        private readonly ManualResetEvent _stopped;
+        private readonly Thread? _thread;
+
+        public ProgressRefreshThread(ProgressContext context, TimeSpan refreshRate)
+        {
+            _context = context ?? throw new ArgumentNullException(nameof(context));
+            _refreshRate = refreshRate;
+            _running = new ManualResetEvent(false);
+            _stopped = new ManualResetEvent(false);
+
+            _thread = new Thread(Run);
+            _thread.IsBackground = true;
+            _thread.Start();
+        }
+
+        public void Dispose()
+        {
+            if (_thread == null || !_running.WaitOne(0))
+            {
+                return;
+            }
+
+            _stopped.Set();
+            _thread.Join();
+
+            _stopped.Dispose();
+            _running.Dispose();
+        }
+
+        private void Run()
+        {
+            _running.Set();
+
+            try
+            {
+                while (!_stopped.WaitOne(_refreshRate))
+                {
+                    _context.Refresh();
+                }
+            }
+            finally
+            {
+                _stopped.Reset();
+                _running.Reset();
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressRenderer.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console.Internal
+{
+    internal abstract class ProgressRenderer : IRenderHook
+    {
+        public abstract TimeSpan RefreshRate { get; }
+
+        public virtual void Started()
+        {
+        }
+
+        public virtual void Completed(bool clear)
+        {
+        }
+
+        public abstract void Update(ProgressContext context);
+        public abstract IEnumerable<IRenderable> Process(RenderContext context, IEnumerable<IRenderable> renderables);
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressSample.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace Spectre.Console.Internal
+{
+    internal readonly struct ProgressSample
+    {
+        public double Value { get; }
+        public DateTime Timestamp { get; }
+
+        public ProgressSample(DateTime timestamp, double value)
+        {
+            Timestamp = timestamp;
+            Value = value;
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressTask.cs

@@ -0,0 +1,281 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Spectre.Console.Internal;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a progress task.
+    /// </summary>
+    public sealed class ProgressTask
+    {
+        private readonly List<ProgressSample> _samples;
+        private readonly object _lock;
+
+        private double _maxValue;
+        private string _description;
+
+        /// <summary>
+        /// Gets the task ID.
+        /// </summary>
+        public int Id { get; }
+
+        /// <summary>
+        /// Gets or sets the task description.
+        /// </summary>
+        public string Description
+        {
+            get => _description;
+            set => Update(description: value);
+        }
+
+        /// <summary>
+        /// Gets or sets the max value of the task.
+        /// </summary>
+        public double MaxValue
+        {
+            get => _maxValue;
+            set => Update(maxValue: value);
+        }
+
+        /// <summary>
+        /// Gets the value of the task.
+        /// </summary>
+        public double Value { get; private set; }
+
+        /// <summary>
+        /// Gets the start time of the task.
+        /// </summary>
+        public DateTime? StartTime { get; private set; }
+
+        /// <summary>
+        /// Gets the stop time of the task.
+        /// </summary>
+        public DateTime? StopTime { get; private set; }
+
+        /// <summary>
+        /// Gets the task state.
+        /// </summary>
+        public ProgressTaskState State { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the task has started.
+        /// </summary>
+        public bool IsStarted => StartTime != null;
+
+        /// <summary>
+        /// Gets a value indicating whether or not the task has finished.
+        /// </summary>
+        public bool IsFinished => Value >= MaxValue;
+
+        /// <summary>
+        /// Gets the percentage done of the task.
+        /// </summary>
+        public double Percentage => GetPercentage();
+
+        /// <summary>
+        /// Gets the speed measured in steps/second.
+        /// </summary>
+        public double? Speed => GetSpeed();
+
+        /// <summary>
+        /// Gets the elapsed time.
+        /// </summary>
+        public TimeSpan? ElapsedTime => GetElapsedTime();
+
+        /// <summary>
+        /// Gets the remaining time.
+        /// </summary>
+        public TimeSpan? RemainingTime => GetRemainingTime();
+
+        internal ProgressTask(int id, string description, double maxValue, bool autoStart)
+        {
+            _samples = new List<ProgressSample>();
+            _lock = new object();
+            _maxValue = maxValue;
+
+            _description = description?.RemoveNewLines()?.Trim() ?? throw new ArgumentNullException(nameof(description));
+            if (string.IsNullOrWhiteSpace(_description))
+            {
+                throw new ArgumentException("Task name cannot be empty", nameof(description));
+            }
+
+            Id = id;
+            State = new ProgressTaskState();
+            Value = 0;
+            StartTime = autoStart ? DateTime.Now : null;
+        }
+
+        /// <summary>
+        /// Starts the task.
+        /// </summary>
+        public void StartTask()
+        {
+            lock (_lock)
+            {
+                StartTime = DateTime.Now;
+                StopTime = null;
+            }
+        }
+
+        /// <summary>
+        /// Stops the task.
+        /// </summary>
+        public void StopTask()
+        {
+            lock (_lock)
+            {
+                var now = DateTime.Now;
+                if (StartTime == null)
+                {
+                    StartTime = now;
+                }
+
+                StopTime = now;
+            }
+        }
+
+        /// <summary>
+        /// Increments the task's value.
+        /// </summary>
+        /// <param name="value">The value to increment with.</param>
+        public void Increment(double value)
+        {
+            Update(increment: value);
+        }
+
+        private void Update(
+            string? description = null,
+            double? maxValue = null,
+            double? increment = null)
+        {
+            lock (_lock)
+            {
+                var startValue = Value;
+
+                if (description != null)
+                {
+                    description = description?.RemoveNewLines()?.Trim();
+                    if (string.IsNullOrWhiteSpace(description))
+                    {
+                        throw new InvalidOperationException("Task name cannot be empty.");
+                    }
+
+                    _description = description;
+                }
+
+                if (maxValue != null)
+                {
+                    _maxValue = maxValue.Value;
+                }
+
+                if (increment != null)
+                {
+                    Value += increment.Value;
+                }
+
+                // Need to cap the max value?
+                if (Value > _maxValue)
+                {
+                    Value = _maxValue;
+                }
+
+                var timestamp = DateTime.Now;
+                var threshold = timestamp - TimeSpan.FromSeconds(30);
+
+                // Remove samples that's too old
+                while (_samples.Count > 0 && _samples[0].Timestamp < threshold)
+                {
+                    _samples.RemoveAt(0);
+                }
+
+                // Keep maximum of 1000 samples
+                while (_samples.Count > 1000)
+                {
+                    _samples.RemoveAt(0);
+                }
+
+                _samples.Add(new ProgressSample(timestamp, Value - startValue));
+            }
+        }
+
+        private double GetPercentage()
+        {
+            var percentage = (Value / MaxValue) * 100;
+            percentage = Math.Min(100, Math.Max(0, percentage));
+            return percentage;
+        }
+
+        private double? GetSpeed()
+        {
+            lock (_lock)
+            {
+                if (StartTime == null)
+                {
+                    return null;
+                }
+
+                if (_samples.Count == 0)
+                {
+                    return null;
+                }
+
+                var totalTime = _samples.Last().Timestamp - _samples[0].Timestamp;
+                if (totalTime == TimeSpan.Zero)
+                {
+                    return null;
+                }
+
+                var totalCompleted = _samples.Sum(x => x.Value);
+                return totalCompleted / totalTime.TotalSeconds;
+            }
+        }
+
+        private TimeSpan? GetElapsedTime()
+        {
+            lock (_lock)
+            {
+                if (StartTime == null)
+                {
+                    return null;
+                }
+
+                if (StopTime != null)
+                {
+                    return StopTime - StartTime;
+                }
+
+                return DateTime.Now - StartTime;
+            }
+        }
+
+        private TimeSpan? GetRemainingTime()
+        {
+            lock (_lock)
+            {
+                if (IsFinished)
+                {
+                    return TimeSpan.Zero;
+                }
+
+                var speed = GetSpeed();
+                if (speed == null)
+                {
+                    return null;
+                }
+
+                // If the speed is zero, the estimate below
+                // will return infinity (since it's a double),
+                // so let's set the speed to 1 in that case.
+                if (speed == 0)
+                {
+                    speed = 1;
+                }
+
+                var estimate = (MaxValue - Value) / speed.Value;
+                return TimeSpan.FromSeconds(estimate);
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressTaskSettings.cs

@@ -0,0 +1,20 @@
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents settings for a progress task.
+    /// </summary>
+    public sealed class ProgressTaskSettings
+    {
+        /// <summary>
+        /// Gets or sets the task's max value.
+        /// Defaults to <c>100</c>.
+        /// </summary>
+        public double MaxValue { get; set; } = 100;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not the task
+        /// will be auto started. Defaults to <c>true</c>.
+        /// </summary>
+        public bool AutoStart { get; set; } = true;
+    }
+}

src/Spectre.Console/Widgets/Progress/ProgressTaskState.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents progress task state.
+    /// </summary>
+    public sealed class ProgressTaskState
+    {
+        private readonly Dictionary<string, object> _state;
+        private readonly object _lock;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProgressTaskState"/> class.
+        /// </summary>
+        public ProgressTaskState()
+        {
+            _state = new Dictionary<string, object>();
+            _lock = new object();
+        }
+
+        /// <summary>
+        /// Gets the state value for the specified key.
+        /// </summary>
+        /// <typeparam name="T">The state value type.</typeparam>
+        /// <param name="key">The state key.</param>
+        /// <returns>The value for the specified key.</returns>
+        public T Get<T>(string key)
+            where T : struct
+        {
+            lock (_lock)
+            {
+                if (!_state.TryGetValue(key, out var value))
+                {
+                    return default;
+                }
+
+                if (!(value is T))
+                {
+                    throw new InvalidOperationException("State value is of the wrong type.");
+                }
+
+                return (T)value;
+            }
+        }
+
+        /// <summary>
+        /// Updates a task state value.
+        /// </summary>
+        /// <typeparam name="T">The state value type.</typeparam>
+        /// <param name="key">The key.</param>
+        /// <param name="func">The transformation function.</param>
+        /// <returns>The updated value.</returns>
+        public T Update<T>(string key, Func<T, T> func)
+            where T : struct
+        {
+            lock (_lock)
+            {
+                if (func is null)
+                {
+                    throw new ArgumentNullException(nameof(func));
+                }
+
+                var old = default(T);
+                if (_state.TryGetValue(key, out var value))
+                {
+                    if (!(value is T))
+                    {
+                        throw new InvalidOperationException("State value is of the wrong type.");
+                    }
+
+                    old = (T)value;
+                }
+
+                _state[key] = func(old);
+                return (T)_state[key];
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Renderers/DefaultProgressRenderer.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console.Internal
+{
+    internal sealed class DefaultProgressRenderer : ProgressRenderer
+    {
+        private readonly IAnsiConsole _console;
+        private readonly List<ProgressColumn> _columns;
+        private readonly LiveRenderable _live;
+        private readonly object _lock;
+        private readonly Stopwatch _stopwatch;
+        private TimeSpan _lastUpdate;
+
+        public override TimeSpan RefreshRate { get; }
+
+        public DefaultProgressRenderer(IAnsiConsole console, List<ProgressColumn> columns, TimeSpan refreshRate)
+        {
+            _console = console ?? throw new ArgumentNullException(nameof(console));
+            _columns = columns ?? throw new ArgumentNullException(nameof(columns));
+            _live = new LiveRenderable();
+            _lock = new object();
+            _stopwatch = new Stopwatch();
+            _lastUpdate = TimeSpan.Zero;
+
+            RefreshRate = refreshRate;
+        }
+
+        public override void Started()
+        {
+            _console.Cursor.Hide();
+        }
+
+        public override void Completed(bool clear)
+        {
+            lock (_lock)
+            {
+                if (clear)
+                {
+                    _console.Render(_live.RestoreCursor());
+                }
+                else
+                {
+                    _console.WriteLine();
+                }
+
+                _console.Cursor.Show();
+            }
+        }
+
+        public override void Update(ProgressContext context)
+        {
+            lock (_lock)
+            {
+                if (!_stopwatch.IsRunning)
+                {
+                    _stopwatch.Start();
+                }
+
+                var renderContext = new RenderContext(_console.Encoding, _console.Capabilities.LegacyConsole);
+
+                var delta = _stopwatch.Elapsed - _lastUpdate;
+                _lastUpdate = _stopwatch.Elapsed;
+
+                var grid = new Grid();
+                for (var columnIndex = 0; columnIndex < _columns.Count; columnIndex++)
+                {
+                    var column = new GridColumn().PadRight(1);
+
+                    var columnWidth = _columns[columnIndex].GetColumnWidth(renderContext);
+                    if (columnWidth != null)
+                    {
+                        column.Width = columnWidth;
+                    }
+
+                    if (_columns[columnIndex].NoWrap)
+                    {
+                        column.NoWrap();
+                    }
+
+                    // Last column?
+                    if (columnIndex == _columns.Count - 1)
+                    {
+                        column.PadRight(0);
+                    }
+
+                    grid.AddColumn(column);
+                }
+
+                // Add rows
+                foreach (var task in context.GetTasks())
+                {
+                    var columns = _columns.Select(column => column.Render(renderContext, task, delta));
+                    grid.AddRow(columns.ToArray());
+                }
+
+                _live.SetRenderable(new Padder(grid, new Padding(0, 1)));
+            }
+        }
+
+        public override IEnumerable<IRenderable> Process(RenderContext context, IEnumerable<IRenderable> renderables)
+        {
+            lock (_lock)
+            {
+                yield return _live.PositionCursor();
+
+                foreach (var renderable in renderables)
+                {
+                    yield return renderable;
+                }
+
+                yield return _live;
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Renderers/FallbackProgressRenderer.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console.Internal
+{
+    internal sealed class FallbackProgressRenderer : ProgressRenderer
+    {
+        private const double FirstMilestone = 25;
+        private static readonly double?[] _milestones = new double?[] { FirstMilestone, 50, 75, 95, 96, 97, 98, 99, 100 };
+
+        private readonly Dictionary<int, double> _taskMilestones;
+        private readonly object _lock;
+        private IRenderable? _renderable;
+        private DateTime _lastUpdate;
+
+        public override TimeSpan RefreshRate => TimeSpan.FromSeconds(1);
+
+        public FallbackProgressRenderer()
+        {
+            _taskMilestones = new Dictionary<int, double>();
+            _lock = new object();
+        }
+
+        public override void Update(ProgressContext context)
+        {
+            lock (_lock)
+            {
+                var hasStartedTasks = false;
+                var updates = new List<(string, double)>();
+
+                foreach (var task in context.GetTasks())
+                {
+                    if (!task.IsStarted || task.IsFinished)
+                    {
+                        return;
+                    }
+
+                    hasStartedTasks = true;
+
+                    if (TryAdvance(task.Id, task.Percentage))
+                    {
+                        updates.Add((task.Description, task.Percentage));
+                    }
+                }
+
+                // Got started tasks but no updates for 30 seconds?
+                if (hasStartedTasks && updates.Count == 0 && (DateTime.Now - _lastUpdate) > TimeSpan.FromSeconds(30))
+                {
+                    foreach (var task in context.GetTasks())
+                    {
+                        updates.Add((task.Description, task.Percentage));
+                    }
+                }
+
+                if (updates.Count > 0)
+                {
+                    _lastUpdate = DateTime.Now;
+                }
+
+                _renderable = BuildTaskGrid(updates);
+            }
+        }
+
+        public override IEnumerable<IRenderable> Process(RenderContext context, IEnumerable<IRenderable> renderables)
+        {
+            lock (_lock)
+            {
+                var result = new List<IRenderable>();
+                result.AddRange(renderables);
+
+                if (_renderable != null)
+                {
+                    result.Add(_renderable);
+                }
+
+                _renderable = null;
+
+                return result;
+            }
+        }
+
+        private bool TryAdvance(int task, double percentage)
+        {
+            if (!_taskMilestones.TryGetValue(task, out var milestone))
+            {
+                _taskMilestones.Add(task, FirstMilestone);
+                return true;
+            }
+
+            if (percentage > milestone)
+            {
+                var nextMilestone = GetNextMilestone(percentage);
+                if (nextMilestone != null && _taskMilestones[task] != nextMilestone)
+                {
+                    _taskMilestones[task] = nextMilestone.Value;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static double? GetNextMilestone(double percentage)
+        {
+            return Array.Find(_milestones, p => p > percentage);
+        }
+
+        private static IRenderable? BuildTaskGrid(List<(string Name, double Percentage)> updates)
+        {
+            if (updates.Count > 0)
+            {
+                var renderables = new List<IRenderable>();
+                foreach (var (name, percentage) in updates)
+                {
+                    renderables.Add(new Markup($"[blue]{name}[/]: {(int)percentage}%"));
+                }
+
+                return new Rows(renderables);
+            }
+
+            return null;
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Renderers/StatusFallbackRenderer.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console.Internal
+{
+    internal sealed class StatusFallbackRenderer : ProgressRenderer
+    {
+        private readonly object _lock;
+        private IRenderable? _renderable;
+        private string? _lastStatus;
+
+        public override TimeSpan RefreshRate => TimeSpan.FromMilliseconds(100);
+
+        public StatusFallbackRenderer()
+        {
+            _lock = new object();
+        }
+
+        public override void Update(ProgressContext context)
+        {
+            lock (_lock)
+            {
+                var task = context.GetTasks().SingleOrDefault();
+                if (task != null)
+                {
+                    // Not same description?
+                    if (_lastStatus != task.Description)
+                    {
+                        _lastStatus = task.Description;
+                        _renderable = new Markup(task.Description + Environment.NewLine);
+                        return;
+                    }
+                }
+
+                _renderable = null;
+                return;
+            }
+        }
+
+        public override IEnumerable<IRenderable> Process(RenderContext context, IEnumerable<IRenderable> renderables)
+        {
+            lock (_lock)
+            {
+                var result = new List<IRenderable>();
+                result.AddRange(renderables);
+
+                if (_renderable != null)
+                {
+                    result.Add(_renderable);
+                }
+
+                _renderable = null;
+
+                return result;
+            }
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/Spinner.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a spinner used in a <see cref="SpinnerColumn"/>.
+    /// </summary>
+    public abstract partial class Spinner
+    {
+        /// <summary>
+        /// Gets the update interval for the spinner.
+        /// </summary>
+        public abstract TimeSpan Interval { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the spinner
+        /// uses Unicode characters.
+        /// </summary>
+        public abstract bool IsUnicode { get; }
+
+        /// <summary>
+        /// Gets the spinner frames.
+        /// </summary>
+        public abstract IReadOnlyList<string> Frames { get; }
+    }
+}

src/Spectre.Console/Widgets/Progress/Status.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Threading.Tasks;
+using Spectre.Console.Internal;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a status display.
+    /// </summary>
+    public sealed class Status
+    {
+        private readonly IAnsiConsole _console;
+
+        /// <summary>
+        /// Gets or sets the spinner.
+        /// </summary>
+        public Spinner? Spinner { get; set; }
+
+        /// <summary>
+        /// Gets or sets the spinner style.
+        /// </summary>
+        public Style? SpinnerStyle { get; set; } = new Style(foreground: Color.Yellow);
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not status
+        /// should auto refresh. Defaults to <c>true</c>.
+        /// </summary>
+        public bool AutoRefresh { get; set; } = true;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Status"/> class.
+        /// </summary>
+        /// <param name="console">The console.</param>
+        public Status(IAnsiConsole console)
+        {
+            _console = console ?? throw new ArgumentNullException(nameof(console));
+        }
+
+        /// <summary>
+        /// Starts a new status display.
+        /// </summary>
+        /// <param name="status">The status to display.</param>
+        /// <param name="action">he action to execute.</param>
+        public void Start(string status, Action<StatusContext> action)
+        {
+            var task = StartAsync(status, ctx =>
+            {
+                action(ctx);
+                return Task.CompletedTask;
+            });
+
+            task.GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Starts a new status display.
+        /// </summary>
+        /// <param name="status">The status to display.</param>
+        /// <param name="action">he action to execute.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public async Task StartAsync(string status, Func<StatusContext, Task> action)
+        {
+            // Set the progress columns
+            var spinnerColumn = new SpinnerColumn(Spinner ?? Spinner.Known.Default)
+            {
+                Style = SpinnerStyle ?? Style.Plain,
+            };
+
+            var progress = new Progress(_console)
+            {
+                FallbackRenderer = new StatusFallbackRenderer(),
+                AutoClear = true,
+                AutoRefresh = AutoRefresh,
+            };
+
+            progress.Columns(new ProgressColumn[]
+            {
+                spinnerColumn,
+                new TaskDescriptionColumn(),
+            });
+
+            await progress.StartAsync(async ctx =>
+            {
+                var statusContext = new StatusContext(ctx, ctx.AddTask(status), spinnerColumn);
+                await action(statusContext).ConfigureAwait(false);
+            }).ConfigureAwait(false);
+        }
+    }
+}

src/Spectre.Console/Widgets/Progress/StatusContext.cs

@@ -0,0 +1,76 @@
+using System;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Represents a context that can be used to interact with a <see cref="Status"/>.
+    /// </summary>
+    public sealed class StatusContext
+    {
+        private readonly ProgressContext _context;
+        private readonly ProgressTask _task;
+        private readonly SpinnerColumn _spinnerColumn;
+
+        /// <summary>
+        /// Gets or sets the current status.
+        /// </summary>
+        public string Status
+        {
+            get => _task.Description;
+            set => SetStatus(value);
+        }
+
+        /// <summary>
+        /// Gets or sets the current spinner.
+        /// </summary>
+        public Spinner Spinner
+        {
+            get => _spinnerColumn.Spinner;
+            set => SetSpinner(value);
+        }
+
+        /// <summary>
+        /// Gets or sets the current spinner style.
+        /// </summary>
+        public Style? SpinnerStyle
+        {
+            get => _spinnerColumn.Style;
+            set => _spinnerColumn.Style = value;
+        }
+
+        internal StatusContext(ProgressContext context, ProgressTask task, SpinnerColumn spinnerColumn)
+        {
+            _context = context ?? throw new ArgumentNullException(nameof(context));
+            _task = task ?? throw new ArgumentNullException(nameof(task));
+            _spinnerColumn = spinnerColumn ?? throw new ArgumentNullException(nameof(spinnerColumn));
+        }
+
+        /// <summary>
+        /// Refreshes the status.
+        /// </summary>
+        public void Refresh()
+        {
+            _context.Refresh();
+        }
+
+        private void SetStatus(string status)
+        {
+            if (status is null)
+            {
+                throw new ArgumentNullException(nameof(status));
+            }
+
+            _task.Description = status;
+        }
+
+        private void SetSpinner(Spinner spinner)
+        {
+            if (spinner is null)
+            {
+                throw new ArgumentNullException(nameof(spinner));
+            }
+
+            _spinnerColumn.Spinner = spinner;
+        }
+    }
+}