refactor: Replace legacy console output system with Console Coordinator architecture

src/ModularPipelines.Azure.Pipelines/AzurePipeline.cs

@@ -1,20 +1,25 @@
+using ModularPipelines.Console;
 using ModularPipelines.Context;
-using ModularPipelines.Logging;
+using ModularPipelines.Engine;
 
 namespace ModularPipelines.Azure.Pipelines;
 
 internal class AzurePipeline : IAzurePipeline
 {
     private readonly IEnvironmentContext _environment;
-    private readonly IModuleOutputWriter _outputWriter;
+    private readonly IModuleOutputBuffer _buffer;
+    private readonly IBuildSystemFormatter _formatter;
 
-    public AzurePipeline(AzurePipelineVariables variables,
+    public AzurePipeline(
+        AzurePipelineVariables variables,
         IEnvironmentContext environment,
-        IModuleOutputWriterFactory outputWriterFactory)
+        IConsoleCoordinator consoleCoordinator,
+        IBuildSystemFormatterProvider formatterProvider)
     {
         _environment = environment;
         Variables = variables;
-        _outputWriter = outputWriterFactory.Create("AzurePipeline");
+        _buffer = consoleCoordinator.GetUnattributedBuffer();
+        _formatter = formatterProvider.GetFormatter();
     }
 
     public bool IsRunningOnAzurePipelines
@@ -24,16 +29,40 @@ public bool IsRunningOnAzurePipelines
 
     public void WriteLine(string message)
     {
-        _outputWriter.WriteLine(message);
+        _buffer.WriteLine(message);
     }
 
-    public void WriteLineDirect(string message)
+    public IDisposable BeginSection(string name)
     {
-        _outputWriter.WriteLineDirect(message);
+        return new OutputSection(_buffer, name, _formatter);
     }
 
-    public IDisposable BeginSection(string name)
+    private sealed class OutputSection : IDisposable
     {
-        return _outputWriter.BeginSection(name);
+        private readonly IModuleOutputBuffer _buffer;
+        private readonly string _name;
+        private readonly IBuildSystemFormatter _formatter;
+
+        public OutputSection(IModuleOutputBuffer buffer, string name, IBuildSystemFormatter formatter)
+        {
+            _buffer = buffer;
+            _name = name;
+            _formatter = formatter;
+
+            var startCommand = formatter.GetStartBlockCommand(name);
+            if (startCommand != null)
+            {
+                _buffer.WriteLine(startCommand);
+            }
+        }
+
+        public void Dispose()
+        {
+            var endCommand = _formatter.GetEndBlockCommand(_name);
+            if (endCommand != null)
+            {
+                _buffer.WriteLine(endCommand);
+            }
+        }
     }
-}
+}

src/ModularPipelines.Azure.Pipelines/IAzurePipeline.cs

@@ -1,10 +1,21 @@
-using ModularPipelines.Logging;
-
 namespace ModularPipelines.Azure.Pipelines;
 
-public interface IAzurePipeline : IModuleOutputWriter
+public interface IAzurePipeline
 {
     public bool IsRunningOnAzurePipelines { get; }
 
     public AzurePipelineVariables Variables { get; }
-}
+
+    /// <summary>
+    /// Writes a message to the console output.
+    /// </summary>
+    /// <param name="message">The message to write.</param>
+    void WriteLine(string message);
+
+    /// <summary>
+    /// Begins a collapsible section in CI output.
+    /// </summary>
+    /// <param name="name">The section name.</param>
+    /// <returns>A disposable that ends the section when disposed.</returns>
+    IDisposable BeginSection(string name);
+}

src/ModularPipelines.GitHub/GitHub.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Options;
+using ModularPipelines.Console;
+using ModularPipelines.Engine;
 using ModularPipelines.GitHub.Options;
-using ModularPipelines.Logging;
 using Octokit;
 using Octokit.Internal;
 
@@ -11,7 +12,8 @@ internal class GitHub : IGitHub
     private readonly GitHubOptions _options;
     private readonly IHttpMessageHandlerFactory _httpMessageHandlerFactory;
     private readonly Lazy<IGitHubClient> _client;
-    private readonly ModuleOutputWriter _outputWriter;
+    private readonly IModuleOutputBuffer _buffer;
+    private readonly IBuildSystemFormatter _formatter;
 
     public IGitHubClient Client => _client.Value;
 
@@ -24,31 +26,26 @@ public GitHub(
       IGitHubEnvironmentVariables environmentVariables,
       IGitHubRepositoryInfo gitHubRepositoryInfo,
       IHttpMessageHandlerFactory httpMessageHandlerFactory,
-      IModuleOutputWriterFactory outputWriterFactory,
-      IModuleLoggerProvider moduleLoggerProvider)
+      IConsoleCoordinator consoleCoordinator,
+      IBuildSystemFormatterProvider formatterProvider)
     {
         _options = options.Value;
         _httpMessageHandlerFactory = httpMessageHandlerFactory;
         EnvironmentVariables = environmentVariables;
-
         _client = new Lazy<IGitHubClient>(InitializeClient);
         RepositoryInfo = gitHubRepositoryInfo;
-        _outputWriter = outputWriterFactory.Create("GitHub", moduleLoggerProvider.GetLogger());
+        _buffer = consoleCoordinator.GetUnattributedBuffer();
+        _formatter = formatterProvider.GetFormatter();
     }
 
     public void WriteLine(string message)
     {
-        _outputWriter.WriteLine(message);
-    }
-
-    public void WriteLineDirect(string message)
-    {
-        _outputWriter.WriteLineDirect(message);
+        _buffer.WriteLine(message);
     }
 
     public IDisposable BeginSection(string name)
     {
-        return _outputWriter.BeginSection(name);
+        return new OutputSection(this, name, _formatter);
     }
 
     // PRIVATE METHODS
@@ -74,4 +71,33 @@ private IGitHubClient InitializeClient()
 
         return client;
     }
+
+    private sealed class OutputSection : IDisposable
+    {
+        private readonly GitHub _github;
+        private readonly string _name;
+        private readonly IBuildSystemFormatter _formatter;
+
+        public OutputSection(GitHub github, string name, IBuildSystemFormatter formatter)
+        {
+            _github = github;
+            _name = name;
+            _formatter = formatter;
+
+            var startCommand = formatter.GetStartBlockCommand(name);
+            if (startCommand != null)
+            {
+                _github._buffer.WriteLine(startCommand);
+            }
+        }
+
+        public void Dispose()
+        {
+            var endCommand = _formatter.GetEndBlockCommand(_name);
+            if (endCommand != null)
+            {
+                _github._buffer.WriteLine(endCommand);
+            }
+        }
+    }
 }

src/ModularPipelines.GitHub/GitHubMarkdownSummaryGenerator.cs

@@ -50,7 +50,7 @@ private async Task WriteFile(IPipelineHookContext pipelineContext, string stepSu
 
         if (newSize > MaxFileSizeInBytes)
         {
-            Console.WriteLine("Appending to the GitHub Step Summary would exceed the 1MB file size limit.");
+            System.Console.WriteLine("Appending to the GitHub Step Summary would exceed the 1MB file size limit.");
             return;
         }
 

src/ModularPipelines.GitHub/GitHubRepositoryInfo.cs

@@ -98,7 +98,7 @@ public async Task InitializeAsync()
         }
         catch (Exception e) when (e is not (OutOfMemoryException or StackOverflowException))
         {
-            Console.WriteLine(e);
+            System.Console.WriteLine(e);
         }
     }
 }

src/ModularPipelines.GitHub/IGitHub.cs

@@ -1,13 +1,25 @@
-using ModularPipelines.Logging;
 using Octokit;
 
 namespace ModularPipelines.GitHub;
 
-public interface IGitHub : IModuleOutputWriter
+public interface IGitHub
 {
     IGitHubClient Client { get; }
 
     IGitHubRepositoryInfo RepositoryInfo { get; }
 
     IGitHubEnvironmentVariables EnvironmentVariables { get; }
-}
+
+    /// <summary>
+    /// Writes a message to the console output.
+    /// </summary>
+    /// <param name="message">The message to write.</param>
+    void WriteLine(string message);
+
+    /// <summary>
+    /// Begins a collapsible section in CI output (GitHub Actions group).
+    /// </summary>
+    /// <param name="name">The section name.</param>
+    /// <returns>A disposable that ends the section when disposed.</returns>
+    IDisposable BeginSection(string name);
+}

src/ModularPipelines.TeamCity/ITeamCity.cs

@@ -1,8 +1,19 @@
-using ModularPipelines.Logging;
-
 namespace ModularPipelines.TeamCity;
 
-public interface ITeamCity : IModuleOutputWriter
+public interface ITeamCity
 {
     ITeamCityEnvironmentVariables EnvironmentVariables { get; }
-}
+
+    /// <summary>
+    /// Writes a message to the console output.
+    /// </summary>
+    /// <param name="message">The message to write.</param>
+    void WriteLine(string message);
+
+    /// <summary>
+    /// Begins a collapsible section in CI output.
+    /// </summary>
+    /// <param name="name">The section name.</param>
+    /// <returns>A disposable that ends the section when disposed.</returns>
+    IDisposable BeginSection(string name);
+}

src/ModularPipelines.TeamCity/TeamCity.cs

@@ -1,32 +1,61 @@
-using ModularPipelines.Logging;
+using ModularPipelines.Console;
+using ModularPipelines.Engine;
 
 namespace ModularPipelines.TeamCity;
 
 internal class TeamCity : ITeamCity
 {
-    private readonly ModuleOutputWriter _outputWriter;
+    private readonly IModuleOutputBuffer _buffer;
+    private readonly IBuildSystemFormatter _formatter;
 
-    public TeamCity(ITeamCityEnvironmentVariables environmentVariables,
-        IModuleOutputWriterFactory outputWriterFactory)
+    public TeamCity(
+        ITeamCityEnvironmentVariables environmentVariables,
+        IConsoleCoordinator consoleCoordinator,
+        IBuildSystemFormatterProvider formatterProvider)
     {
         EnvironmentVariables = environmentVariables;
-        _outputWriter = outputWriterFactory.Create("TeamCity");
+        _buffer = consoleCoordinator.GetUnattributedBuffer();
+        _formatter = formatterProvider.GetFormatter();
     }
 
     public ITeamCityEnvironmentVariables EnvironmentVariables { get; }
 
     public void WriteLine(string message)
     {
-        _outputWriter.WriteLine(message);
+        _buffer.WriteLine(message);
     }
 
-    public void WriteLineDirect(string message)
+    public IDisposable BeginSection(string name)
     {
-        _outputWriter.WriteLineDirect(message);
+        return new OutputSection(_buffer, name, _formatter);
     }
 
-    public IDisposable BeginSection(string name)
+    private sealed class OutputSection : IDisposable
     {
-        return _outputWriter.BeginSection(name);
+        private readonly IModuleOutputBuffer _buffer;
+        private readonly string _name;
+        private readonly IBuildSystemFormatter _formatter;
+
+        public OutputSection(IModuleOutputBuffer buffer, string name, IBuildSystemFormatter formatter)
+        {
+            _buffer = buffer;
+            _name = name;
+            _formatter = formatter;
+
+            var startCommand = formatter.GetStartBlockCommand(name);
+            if (startCommand != null)
+            {
+                _buffer.WriteLine(startCommand);
+            }
+        }
+
+        public void Dispose()
+        {
+            var endCommand = _formatter.GetEndBlockCommand(_name);
+            if (endCommand != null)
+            {
+                _buffer.WriteLine(endCommand);
+            }
+        }
     }
-}
+}