feat: replace dependency tree printer with Spectre.Console visualization

Replace the plain-text dependency chain output with a Spectre.Console Tree
widget for improved readability and visual polish.

Changes:
- DependencyTreeFormatter now returns a Spectre Tree instead of string
- Added proper tree connectors (├──, │, └──)
- Module names are color-coded (blue for first occurrence)
- Shared dependencies marked with dimmed text and (↑) reference marker
- Output goes directly to console (visible by default, not hidden in DEBUG)
- Added Write(IRenderable) to IConsoleWriter interface
- Added 7 unit tests covering various dependency graph scenarios

Example output:
  Module Dependencies
  ├── BuildModule
  │   └── CompileModule
  │       └── TestModule
  └── DeployModule
      └── TestModule (↑)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: thomhurst

src/ModularPipelines/ConsoleWriter.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using Spectre.Console;
+using Spectre.Console.Rendering;
 
 namespace ModularPipelines;
 
@@ -19,4 +20,9 @@ public void LogToConsole(string value)
             System.Console.WriteLine(value);
         }
     }
+
+    public void Write(IRenderable renderable)
+    {
+        AnsiConsole.Write(renderable);
+    }
 }

src/ModularPipelines/Engine/DependencyPrinter.cs

@@ -1,28 +1,25 @@
-using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using ModularPipelines.Interfaces;
 using ModularPipelines.Options;
+using Spectre.Console;
 
 namespace ModularPipelines.Engine;
 
 internal class DependencyPrinter : IDependencyPrinter
 {
     private readonly IDependencyChainProvider _dependencyChainProvider;
-    private readonly ILogger<DependencyPrinter> _logger;
     private readonly IConsoleWriter _consoleWriter;
     private readonly IBuildSystemFormatter _formatter;
     private readonly IOptions<PipelineOptions> _options;
     private readonly IDependencyTreeFormatter _treeFormatter;
 
     public DependencyPrinter(IDependencyChainProvider dependencyChainProvider,
-        ILogger<DependencyPrinter> logger,
         IConsoleWriter consoleWriter,
         IBuildSystemFormatterProvider formatterProvider,
         IOptions<PipelineOptions> options,
         IDependencyTreeFormatter treeFormatter)
     {
         _dependencyChainProvider = dependencyChainProvider;
-        _logger = logger;
         _consoleWriter = consoleWriter;
         _formatter = formatterProvider.GetFormatter();
         _options = options;
@@ -36,34 +33,31 @@ public void PrintDependencyChains()
             return;
         }
 
-        var formattedTree = _treeFormatter.FormatTree(_dependencyChainProvider.ModuleDependencyModels);
-
-        Print(formattedTree);
-    }
-
-    private void Print(string value)
-    {
-        if (string.IsNullOrWhiteSpace(value))
+        var models = _dependencyChainProvider.ModuleDependencyModels;
+        if (!models.Any())
         {
             return;
         }
 
-        _logger.LogDebug("\n");
+        var tree = _treeFormatter.FormatTree(models);
 
-        var startCommand = _formatter.GetStartBlockCommand("Dependency Chains");
+        Print(tree);
+    }
+
+    private void Print(Tree tree)
+    {
+        var startCommand = _formatter.GetStartBlockCommand("Module Dependencies");
         if (startCommand != null)
         {
             _consoleWriter.LogToConsole(startCommand);
         }
 
-        _logger.LogDebug("The following dependency chains have been detected:\r\n{Chain}", value);
+        _consoleWriter.Write(tree);
 
-        var endCommand = _formatter.GetEndBlockCommand("Dependency Chains");
+        var endCommand = _formatter.GetEndBlockCommand("Module Dependencies");
         if (endCommand != null)
         {
             _consoleWriter.LogToConsole(endCommand);
         }
-
-        _logger.LogDebug("\n");
     }
 }

src/ModularPipelines/Engine/DependencyTreeFormatter.cs

@@ -1,30 +1,32 @@
-using System.Text;
 using ModularPipelines.Models;
+using Spectre.Console;
 
 namespace ModularPipelines.Engine;
 
 /// <summary>
-/// Formats dependency trees as text with visual tree structure.
-/// Creates a hierarchical representation using box-drawing characters.
+/// Formats dependency trees using Spectre.Console Tree widget.
+/// Creates a visual hierarchy with proper connectors, colors, and DAG support.
 /// </summary>
 /// <example>
 /// <code>
 /// // Example output:
-/// // ▶ RootModule
-/// //   └─ DependentModule1
-/// //     └─ DependentModule2
-/// //   └─ DependentModule3
+/// // Module Dependencies
+/// // ├── BuildModule
+/// // │   └── CompileModule
+/// // │       └── TestModule
+/// // └── DeployModule
+/// //     └── TestModule (↑)
 /// //
 /// var formatter = new DependencyTreeFormatter();
 /// var tree = formatter.FormatTree(rootModules);
-/// Console.WriteLine(tree);
+/// AnsiConsole.Write(tree);
 /// </code>
 /// </example>
 internal class DependencyTreeFormatter : IDependencyTreeFormatter
 {
-    public string FormatTree(IEnumerable<ModuleDependencyModel> rootModules)
+    public Tree FormatTree(IEnumerable<ModuleDependencyModel> rootModules)
     {
-        var stringBuilder = new StringBuilder();
+        var tree = new Tree("[bold]Module Dependencies[/]");
         var alreadyPrinted = new HashSet<ModuleDependencyModel>();
 
         foreach (var rootModule in rootModules.OrderBy(m => m.AllDescendantDependencies().Count()))
@@ -34,27 +36,31 @@ public string FormatTree(IEnumerable<ModuleDependencyModel> rootModules)
                 continue;
             }
 
-            stringBuilder.AppendLine();
-            AppendNode(stringBuilder, rootModule, 1, alreadyPrinted);
+            AddNode(tree, rootModule, alreadyPrinted);
         }
 
-        return stringBuilder.ToString();
+        return tree;
     }
 
-    private void AppendNode(StringBuilder sb, ModuleDependencyModel node, int depth, ISet<ModuleDependencyModel> alreadyPrinted)
+    private void AddNode(IHasTreeNodes parent, ModuleDependencyModel node, HashSet<ModuleDependencyModel> alreadyPrinted)
     {
+        var isReference = alreadyPrinted.Contains(node);
         alreadyPrinted.Add(node);
 
-        var indent = new string(' ', (depth - 1) * 2);
-        var prefix = depth == 1 ? "▶ " : "└─ ";
+        var moduleName = node.Module.GetType().Name;
+        var label = isReference
+            ? $"[dim italic]{moduleName}[/] [grey](↑)[/]"
+            : $"[blue]{moduleName}[/]";
 
-        sb.Append(indent);
-        sb.Append(prefix);
-        sb.AppendLine(node.Module.GetType().Name);
+        var treeNode = parent.AddNode(label);
 
-        foreach (var dependent in node.IsDependencyFor)
+        // Don't recurse into references - their children are shown elsewhere
+        if (!isReference)
         {
-            AppendNode(sb, dependent, depth + 1, alreadyPrinted);
+            foreach (var dependent in node.IsDependencyFor)
+            {
+                AddNode(treeNode, dependent, alreadyPrinted);
+            }
         }
     }
 }
@@ -65,9 +71,9 @@ private void AppendNode(StringBuilder sb, ModuleDependencyModel node, int depth,
 internal interface IDependencyTreeFormatter
 {
     /// <summary>
-    /// Formats a collection of root dependency modules as a tree structure.
+    /// Formats a collection of root dependency modules as a Spectre.Console tree.
     /// </summary>
     /// <param name="rootModules">The root modules to format.</param>
-    /// <returns>A formatted string representation of the dependency tree.</returns>
-    string FormatTree(IEnumerable<ModuleDependencyModel> rootModules);
+    /// <returns>A Spectre.Console Tree representing the dependency hierarchy.</returns>
+    Tree FormatTree(IEnumerable<ModuleDependencyModel> rootModules);
 }

src/ModularPipelines/IConsoleWriter.cs

@@ -1,4 +1,5 @@
 using ModularPipelines.Logging;
+using Spectre.Console.Rendering;
 
 namespace ModularPipelines;
 
@@ -30,4 +31,10 @@ public interface IConsoleWriter
     /// </summary>
     /// <param name="value">The value to write.</param>
     void LogToConsole(string value);
+
+    /// <summary>
+    /// Writes a Spectre.Console renderable to the console.
+    /// </summary>
+    /// <param name="renderable">The renderable object to write (Tree, Table, Panel, etc.).</param>
+    void Write(IRenderable renderable);
 }

src/ModularPipelines/Logging/ModuleLogger.cs

@@ -3,6 +3,8 @@
 using ModularPipelines.Console;
 using ModularPipelines.Engine;
 using ModularPipelines.Helpers;
+using Spectre.Console;
+using Spectre.Console.Rendering;
 
 namespace ModularPipelines.Logging;
 
@@ -54,6 +56,8 @@ internal abstract class ModuleLogger : IInternalModuleLogger, IConsoleWriter
 
     public abstract void LogToConsole(string value);
 
+    public abstract void Write(IRenderable renderable);
+
     public void SetException(Exception exception)
     {
         _exception = exception;
@@ -148,6 +152,20 @@ public override void LogToConsole(string value)
         _buffer.WriteLine(obfuscated);
     }
 
+    public override void Write(IRenderable renderable)
+    {
+        // Render to string for buffering, then obfuscate
+        using var writer = new StringWriter();
+        var console = AnsiConsole.Create(new AnsiConsoleSettings
+        {
+            Out = new AnsiConsoleOutput(writer),
+        });
+        console.Write(renderable);
+        var rendered = writer.ToString();
+        var obfuscated = _secretObfuscator.Obfuscate(rendered, null) ?? rendered;
+        _buffer.WriteLine(obfuscated);
+    }
+
     private Func<object, Exception?, string> MapFormatter<TState>(Func<TState, Exception?, string>? formatter)
     {
         if (formatter is null)