feat(cli): add revela info command tree with TUI inlining (#23)

Adds three new diagnostic commands plus the inlining mechanism that
lets a parent command render flat in the interactive menu while
keeping a clean nested CLI surface.

Commands:

  revela info                     Revela summary panel (default action)
  revela info plugins             Lists installed plugins
  revela info plugins <name>      Plugin detail (Phase 2, plugin-provided)
  revela info themes              Lists installed themes (active marker)
  revela info themes <name>       Theme detail (Phase 2, theme-provided)

TUI rendering:

  Info
    Revela              ← virtual default-action entry
    Plugins →           ← only shown when plugins register sub-subcommands
    Themes →            ← only shown when themes register sub-subcommands
  > Exit

The menu group is registered with order 90 (bottom of main menu, above
Exit). Plugins/themes contribute per-package detail subcommands via the
existing multi-level `ParentCommand` mechanism ("info plugins" or
"info themes") — no SDK API change required.

Mechanism (CommandDescriptor + CommandOrderRegistry + MenuChoice):

  - New opt-in fields `InlineInMenu` and `InlineDefaultActionLabel`
    on CommandDescriptor (default false → zero impact on existing
    descriptors).
  - InteractiveMenuService.BuildGroupedSelectionPrompt expands inlined
    parents into a virtual default-action entry plus visible sub-
    subcommands, each with absolute path overrides so CLI dispatch
    remains correct.
  - Inlined subcommands without nested children are filtered out — a
    leaf entry with no extension provides no menu value beyond the
    parent's default action.

Bug fix bundled in:

  ShowMainMenuAsync had its own dispatch switch that hardcoded
  `[selection.Command.Name]` for the args path, ignoring
  CommandPathOverride from inlined entries. Clicking an inlined
  subcommand at top level produced `Unrecognized command or argument`
  from System.CommandLine. The top-level menu now routes through the
  same HandleMenuActionAsync as nested menus, honoring the override.

Plugin convention documented in .github/instructions/plugins.instructions.md:
  info subcommands are read-only diagnostics (no prompts, compact
  output suitable for bug-report copy-paste, safe without project).

Author: kirkone

.github/instructions/plugins.instructions.md

@@ -56,12 +56,37 @@ public sealed class MyFeaturePlugin : IPlugin
 | Param | Meaning |
 |-------|---------|
 | `Command` | The `System.CommandLine.Command` instance (from `MyCommand.Create()`) |
-| `ParentCommand` | `null` = root level, `"source"`/`"generate"`/etc. = subcommand. Parent created automatically if missing. |
+| `ParentCommand` | `null` = root level, `"source"`/`"generate"`/etc. = subcommand. Parent created automatically if missing. **Multi-level paths supported** (`"info plugins"` → `revela info plugins <name>`). |
 | `Order` | Sort order within parent (default 50; lower = earlier) |
 | `Group` | Display group label in interactive menu |
 | `RequiresProject` | `false` = available without `project.json` (e.g. `init`, `setup`) |
 | `HideWhenProjectExists` | `true` = hidden inside a project (e.g. setup wizards) |
 | `IsSequentialStep` | `true` = picked up by CLI `generate all` discovery. Pair with `IPipelineStep` for engine/MCP. |
+| `InlineInMenu` | Host-only flag (`info` command tree). Plugins should not need this. |
+| `InlineDefaultActionLabel` | Required when `InlineInMenu = true`. Plugins should not need this. |
+
+## `info` Subcommands — Convention for Plugins
+Plugins **may** contribute one read-only diagnostic subcommand under
+`revela info plugins <plugin-name>` by registering with
+`ParentCommand: "info plugins"`. This is opt-in; nothing breaks if you skip it.
+
+```csharp
+yield return new CommandDescriptor(
+    myInfoCommand.Create(),
+    ParentCommand: "info plugins",
+    Order: 10);
+```
+
+Hard rules for `info` subcommands:
+- **Read-only.** No prompts, no writes, no network calls that mutate state.
+- **Compact.** Output sized for bug-report copy-paste — typically a single
+  Spectre `Panel` with key/value lines. No tables that scroll.
+- **Fast.** No long-running work; user expects a tap-and-read response.
+- **Safe without context.** Must not crash when invoked without an active
+  project (e.g. report "no project loaded" instead of throwing).
+- **No side effects on cache, auth, or files.** This is diagnostics, not
+  troubleshooting tooling. Use a dedicated `doctor` or `check` command if
+  you need active probing.
 
 ## Plugin Configuration
 1. Create config class with `[RevelaConfig("Spectara.Revela.Plugins.MyFeature")]` — full package ID is the JSON section name.

src/Cli/Hosting/CommandGroupRegistry.cs

@@ -19,6 +19,9 @@ internal static class CommandGroups
     /// <summary>Plugin addons and optional features.</summary>
     public const string Addons = "Addons";
 
+    /// <summary>Diagnostic / about commands (main menu, bottom).</summary>
+    public const string Info = "Info";
+
     // Config submenu groups
 
     /// <summary>Core project configuration commands (config submenu).</summary>

src/Cli/Hosting/CommandOrderRegistry.cs

@@ -24,6 +24,7 @@ internal sealed class CommandOrderRegistry
     private readonly HashSet<Command> noProjectRequired = [];
     private readonly HashSet<Command> hideWhenProjectExists = [];
     private readonly HashSet<Command> pipelineSteps = [];
+    private readonly Dictionary<Command, string> inlinedParents = [];
 
     /// <summary>
     /// Registers the display order for a command.
@@ -86,6 +87,33 @@ internal sealed class CommandOrderRegistry
     /// <returns>True if the command is a pipeline step.</returns>
     public bool IsPipelineStep(Command command) => pipelineSteps.Contains(command);
 
+    /// <summary>
+    /// Marks a command as an inlined parent for the interactive menu.
+    /// </summary>
+    /// <remarks>
+    /// Inlined parents are not rendered as a single navigable entry. Instead
+    /// the menu renders a virtual entry for the command's default action
+    /// (labeled by <paramref name="defaultActionLabel"/>) and lists the
+    /// command's visible subcommands directly under the same group label.
+    /// CLI behavior is unaffected.
+    /// </remarks>
+    /// <param name="command">The parent command to render inline.</param>
+    /// <param name="defaultActionLabel">Display label for the virtual default-action entry.</param>
+    public void RegisterInlinedParent(Command command, string defaultActionLabel) =>
+        inlinedParents[command] = defaultActionLabel;
+
+    /// <summary>
+    /// Gets whether a command is registered as an inlined parent.
+    /// </summary>
+    public bool IsInlinedParent(Command command) => inlinedParents.ContainsKey(command);
+
+    /// <summary>
+    /// Gets the display label for an inlined parent's default-action entry,
+    /// or <c>null</c> if the command is not registered as inlined.
+    /// </summary>
+    public string? GetInlineDefaultActionLabel(Command command) =>
+        inlinedParents.TryGetValue(command, out var label) ? label : null;
+
     /// <summary>
     /// Gets the display order for a command.
     /// </summary>

src/Cli/Hosting/CoreCommandProvider.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Spectara.Revela.Commands.Config;
+using Spectara.Revela.Commands.Info;
 using Spectara.Revela.Features.Generate.Commands;
 using Spectara.Revela.Features.Theme.Commands;
 using Spectara.Revela.Sdk.Abstractions;
@@ -94,6 +95,28 @@ public IEnumerable<CommandDescriptor> GetCommands(IServiceProvider services)
             Group: CommandGroups.Addons,
             RequiresProject: false);
 
+        // ── Info group (TUI rendered inline: Revela / Plugins → / Themes →) ──
+        var infoCommand = services.GetRequiredService<InfoCommand>();
+        yield return new CommandDescriptor(
+            infoCommand.Create(),
+            Order: 10,
+            Group: CommandGroups.Info,
+            RequiresProject: false,
+            InlineInMenu: true,
+            InlineDefaultActionLabel: "Revela");
+
+        var infoPluginsCommand = services.GetRequiredService<InfoPluginsCommand>();
+        yield return new CommandDescriptor(
+            infoPluginsCommand.Create(),
+            ParentCommand: "info",
+            Order: 20);
+
+        var infoThemesCommand = services.GetRequiredService<InfoThemesCommand>();
+        yield return new CommandDescriptor(
+            infoThemesCommand.Create(),
+            ParentCommand: "info",
+            Order: 30);
+
         // Restore, Plugin, and Packages commands are provided by PackagesCommandProvider
         // (only available in Cli, not in Cli.Embedded)
 

src/Cli/Hosting/HostExtensions.cs

@@ -60,6 +60,7 @@ public static RootCommand UseRevelaCommands(
         groupRegistry.Register(CommandGroups.Content, 20);
         groupRegistry.Register(CommandGroups.Setup, 30);
         groupRegistry.Register(CommandGroups.Addons, 40);
+        groupRegistry.Register(CommandGroups.Info, 90);
 
         // Create root command
         var rootCommand = new RootCommand(description);
@@ -95,6 +96,17 @@ void OnCommandRegistered(Command cmd, CommandDescriptor desc)
                     pipelineOrderProvider.Register(desc.ParentCommand, cmd.Name, desc.Order);
                 }
             }
+
+            if (desc.InlineInMenu)
+            {
+                if (string.IsNullOrEmpty(desc.InlineDefaultActionLabel))
+                {
+                    throw new InvalidOperationException(
+                        $"Command '{cmd.Name}' has InlineInMenu=true but no InlineDefaultActionLabel. " +
+                        "Provide a label for the virtual default-action menu entry.");
+                }
+                orderRegistry.RegisterInlinedParent(cmd, desc.InlineDefaultActionLabel);
+            }
         }
 
         // Core commands (via CoreCommandProvider — uses same registration as plugins

src/Cli/Hosting/InteractiveMenuService.cs

@@ -72,7 +72,7 @@ public async Task<int> RunAsync(CancellationToken cancellationToken = default)
 
     private async Task<int> HandleFirstRunAsync(CancellationToken cancellationToken)
     {
-        ConsoleUI.ClearAndShowLogo();
+        ConsoleUI.ClearConsole();
         ConsoleUI.ShowFirstRunPanel();
 
         var wizard = setupWizards.FirstOrDefault();
@@ -111,7 +111,7 @@ private async Task<int> HandleFirstRunAsync(CancellationToken cancellationToken)
 
     private async Task<int> HandleNoProjectAsync(CancellationToken cancellationToken)
     {
-        ConsoleUI.ClearAndShowLogo();
+        ConsoleUI.ClearConsole();
 
         var folderName = projectEnvironment.Value.FolderName;
 
@@ -175,7 +175,7 @@ private void ShowWelcomeBanner()
 
         bannerShown = true;
 
-        ConsoleUI.ClearAndShowLogo();
+        ConsoleUI.ClearConsole();
 
         // Show project name if initialized, otherwise show folder name
         var projectName = projectConfig.CurrentValue.Name;
@@ -208,14 +208,15 @@ private async Task<MenuResult> ShowMainMenuAsync(CancellationToken cancellationT
 
         var selection = AnsiConsole.Prompt(prompt);
 
+        // Top-level dispatch: Exit/Back/Wizard handled here; Navigate/Execute
+        // delegate to HandleMenuActionAsync so CommandPathOverride from inlined
+        // entries (e.g. "Plugins" → ["info","plugins"]) is honored.
         return selection.Action switch
         {
             MenuAction.Exit => new MenuResult(true, 0),
             MenuAction.Back => new MenuResult(false, 0),
-            MenuAction.Navigate => await NavigateToCommandAsync(selection.Command!, [selection.Command!.Name], cancellationToken),
-            MenuAction.Execute => await ExecuteCommandAsync(selection.Command!, [selection.Command!.Name], cancellationToken),
             MenuAction.RunSetupWizard => await RunSetupWizardAsync(cancellationToken),
-            _ => new MenuResult(false, 0),
+            MenuAction.Navigate or MenuAction.Execute or _ => await HandleMenuActionAsync(selection, [], cancellationToken),
         };
     }
 
@@ -295,7 +296,9 @@ private async Task<MenuResult> HandleMenuActionAsync(
             return await RunSetupWizardAsync(cancellationToken);
         }
 
-        var extendedPath = new List<string>(commandPath) { selection.Command!.Name };
+        var extendedPath = selection.CommandPathOverride is not null
+            ? [.. selection.CommandPathOverride]
+            : new List<string>(commandPath) { selection.Command!.Name };
 
         return selection.Action switch
         {
@@ -388,7 +391,7 @@ private SelectionPrompt<MenuChoice> BuildGroupedSelectionPrompt(
         // Calculate column width from longest command name (+ 2 for " →" arrow)
         var allCommands = grouped.SelectMany(g => g.Commands).ToList();
         var nameWidth = allCommands.Count > 0
-            ? allCommands.Max(c => c.Name.Length + (c.Subcommands.Any(s => !s.Hidden) ? 2 : 0)) + 2
+            ? allCommands.Max(c => MaxRenderedNameLength(c)) + 2
             : 0;
 
         if (hasGroups)
@@ -406,7 +409,11 @@ private SelectionPrompt<MenuChoice> BuildGroupedSelectionPrompt(
                 {
                     // Create group header as MenuChoice (will be non-selectable due to Leaf mode)
                     var groupChoice = new MenuChoice(groupName, Action: MenuAction.Navigate);
-                    var commandChoices = groupCommands.Select(c => MenuChoice.FromCommand(c, orderRegistry.IsPipelineStep(c), nameWidth)).ToList();
+                    var commandChoices = new List<MenuChoice>();
+                    foreach (var cmd in groupCommands)
+                    {
+                        AddGroupCommandChoices(commandChoices, cmd, nameWidth);
+                    }
 
                     // Add Wizard to the Addons group (as last item)
                     if (includeSetupWizard && groupName == CommandGroups.Addons)
@@ -421,7 +428,7 @@ private SelectionPrompt<MenuChoice> BuildGroupedSelectionPrompt(
                     // Ungrouped commands - add directly
                     foreach (var cmd in groupCommands)
                     {
-                        prompt.AddChoice(MenuChoice.FromCommand(cmd, orderRegistry.IsPipelineStep(cmd), nameWidth));
+                        AddUngroupedCommandChoices(prompt, cmd, nameWidth);
                     }
                 }
             }
@@ -444,6 +451,91 @@ private SelectionPrompt<MenuChoice> BuildGroupedSelectionPrompt(
         return prompt;
     }
 
+    /// <summary>
+    /// Adds menu choices for a command appearing in a grouped section.
+    /// Inlined parents are expanded into a virtual default-action entry plus
+    /// each visible subcommand (with absolute path overrides).
+    /// </summary>
+    private void AddGroupCommandChoices(List<MenuChoice> choices, Command cmd, int nameWidth)
+    {
+        if (TryAddInlined(cmd, nameWidth, choices.Add))
+        {
+            return;
+        }
+        choices.Add(MenuChoice.FromCommand(cmd, orderRegistry.IsPipelineStep(cmd), nameWidth));
+    }
+
+    /// <summary>
+    /// Adds menu choices for an ungrouped command (rare).
+    /// Inlined parents behave the same way as in grouped sections.
+    /// </summary>
+    private void AddUngroupedCommandChoices(SelectionPrompt<MenuChoice> prompt, Command cmd, int nameWidth)
+    {
+        if (TryAddInlined(cmd, nameWidth, choice => prompt.AddChoice(choice)))
+        {
+            return;
+        }
+        prompt.AddChoice(MenuChoice.FromCommand(cmd, orderRegistry.IsPipelineStep(cmd), nameWidth));
+    }
+
+    private bool TryAddInlined(Command cmd, int nameWidth, Action<MenuChoice> add)
+    {
+        var label = orderRegistry.GetInlineDefaultActionLabel(cmd);
+        if (label is null)
+        {
+            return false;
+        }
+
+        // Virtual default-action entry: label runs the parent without subcommand
+        add(MenuChoice.CreateInlinedDefaultAction(cmd, label, nameWidth));
+
+        // Each visible subcommand that itself has at least one visible sub-subcommand
+        // (extension entries registered via ParentCommand: "<parent> <sub>").
+        // Subcommands without any extension are skipped — the parent's default
+        // action already covers their content (e.g. count/list summary).
+        // Absolute path override (parent + sub) ensures correct CLI dispatch.
+        foreach (var sub in cmd.Subcommands
+            .Where(IsInlinableSub)
+            .OrderBy(orderRegistry.GetOrder)
+            .ThenBy(s => s.Name, StringComparer.OrdinalIgnoreCase))
+        {
+            add(MenuChoice.FromCommand(
+                sub,
+                orderRegistry.IsPipelineStep(sub),
+                nameWidth,
+                commandPathOverride: [cmd.Name, sub.Name]));
+        }
+        return true;
+    }
+
+    private static bool IsInlinableSub(Command sub) =>
+        !sub.Hidden && sub.Subcommands.Any(s => !s.Hidden);
+
+    /// <summary>
+    /// Computes the rendered name length used for column alignment, accounting
+    /// for the inline expansion of parents into a default-action label plus
+    /// subcommand entries (each with the " →" arrow when navigable).
+    /// </summary>
+    private int MaxRenderedNameLength(Command cmd)
+    {
+        var label = orderRegistry.GetInlineDefaultActionLabel(cmd);
+        if (label is null)
+        {
+            return cmd.Name.Length + (cmd.Subcommands.Any(s => !s.Hidden) ? 2 : 0);
+        }
+
+        var max = label.Length;
+        foreach (var sub in cmd.Subcommands.Where(IsInlinableSub))
+        {
+            var len = sub.Name.Length + 2; // always navigable when shown
+            if (len > max)
+            {
+                max = len;
+            }
+        }
+        return max;
+    }
+
     [LoggerMessage(Level = LogLevel.Error, Message = "RootCommand not set")]
     private static partial void LogRootCommandNotSet(ILogger logger);