Add support for tracking remaining arguments in command retrieval.

- Refactor `CliTreeNode`, `CliCommandNode`, and `CliCommandGroupNode` to include parent nodes.
- Replace command retrieval methods with `FindCommandNodeResult` to track remaining arguments.
- Update `DefaultCliHost` and `CliCommandStore` to align with new structure.
- Introduce unit tests for enhanced group and command node retrieval.

Author: darthsharp

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/CliCommandGroupNode.cs

@@ -2,7 +2,8 @@
 
 namespace CreativeCoders.Cli.Hosting.Commands.Store;
 
-public class CliCommandGroupNode(string groupName) : CliTreeNode(groupName)
+public class CliCommandGroupNode(string groupName, CliCommandGroupNode? parent)
+    : CliTreeNode(groupName, parent)
 {
     public IEnumerable<CliCommandNode> GetCommands() => ChildNodes.OfType<CliCommandNode>();
 

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/CliCommandNode.cs

@@ -2,7 +2,8 @@
 
 namespace CreativeCoders.Cli.Hosting.Commands.Store;
 
-public class CliCommandNode(CliCommandInfo commandInfo, string command) : CliTreeNode(command)
+public class CliCommandNode(CliCommandInfo commandInfo, string command, CliCommandGroupNode? parent)
+    : CliTreeNode(command, parent)
 {
     public CliCommandInfo CommandInfo { get; } = Ensure.NotNull(commandInfo);
 }

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/CliCommandStore.cs

@@ -16,37 +16,46 @@ public void AddCommands(IEnumerable<CliCommandInfo> commands)
         commands.ForEach(AddCommand);
     }
 
-    public CliCommandInfo? FindCommandForArgs(string[] args)
+    public FindCommandNodeResult<CliCommandGroupNode>? FindCommandGroupNode(string[] args)
     {
-        return FindCommandForArgs(_treeRootNodes, args);
+        return FindCommandGroupNode(null, _treeRootNodes, args);
     }
 
-    public CliCommandGroupNode? FindGroupNodeForArgs(string[] args)
-    {
-        return FindGroupNodeForArgs(null, _treeRootNodes, args);
-    }
-
-    public CliCommandGroupNode? FindGroupNodeForArgs(CliCommandGroupNode? lastGroupNode,
+    private FindCommandNodeResult<CliCommandGroupNode>? FindCommandGroupNode(
+        CliCommandGroupNode? lastGroupNode,
         IEnumerable<CliTreeNode> nodes, string[] args)
     {
         if (args.Length == 0)
         {
-            return null;
+            return lastGroupNode == null
+                ? null
+                : new FindCommandNodeResult<CliCommandGroupNode>(lastGroupNode, []);
         }
 
         var node = nodes.FirstOrDefault(x => x.Name == args[0]);
 
+        var remainingArgs = args.Skip(1).ToArray();
+
         return node switch
         {
-            null => lastGroupNode,
-            CliCommandNode commandNode => commandNode.Parent,
-            CliCommandGroupNode groupNode => FindGroupNodeForArgs(groupNode, groupNode.ChildNodes,
-                args.Skip(1).ToArray()),
+            null => lastGroupNode == null
+                ? null
+                : new FindCommandNodeResult<CliCommandGroupNode>(lastGroupNode, args),
+            CliCommandNode commandNode => new FindCommandNodeResult<CliCommandGroupNode>(commandNode.Parent,
+                args),
+            CliCommandGroupNode groupNode => FindCommandGroupNode(groupNode, groupNode.ChildNodes,
+                remainingArgs),
             _ => null
         };
     }
 
-    private CliCommandInfo? FindCommandForArgs(IEnumerable<CliTreeNode> nodes, string[] args)
+    public FindCommandNodeResult<CliCommandNode>? FindCommandNode(string[] args)
+    {
+        return FindCommandNode(_treeRootNodes, args);
+    }
+
+    private static FindCommandNodeResult<CliCommandNode>? FindCommandNode(IEnumerable<CliTreeNode> nodes,
+        string[] args)
     {
         if (args.Length == 0)
         {
@@ -58,8 +67,10 @@ public void AddCommands(IEnumerable<CliCommandInfo> commands)
         return node switch
         {
             null => null,
-            CliCommandNode commandNode => commandNode.CommandInfo,
-            CliCommandGroupNode groupNode => FindCommandForArgs(groupNode.ChildNodes, args.Skip(1).ToArray()),
+            CliCommandNode commandNode => new FindCommandNodeResult<CliCommandNode>(commandNode,
+                args.Skip(1).ToArray()),
+            CliCommandGroupNode groupNode => FindCommandNode(groupNode.ChildNodes,
+                args.Skip(1).ToArray()),
             _ => null
         };
     }
@@ -79,7 +90,7 @@ private void AddCommand(CliCommandInfo command, string[] commands)
             case 0:
                 throw new InvalidOperationException("Commands must not be empty");
             case 1:
-                _treeRootNodes.Add(new CliCommandNode(command, commands[0]));
+                _treeRootNodes.Add(new CliCommandNode(command, commands[0], null));
                 break;
             default:
             {
@@ -92,7 +103,7 @@ private void AddCommand(CliCommandInfo command, string[] commands)
 
                 _treeRootNodes.Add(groupNode);
 
-                groupNode.ChildNodes.Add(new CliCommandNode(command, commands[^1]));
+                groupNode.ChildNodes.Add(new CliCommandNode(command, commands[^1], groupNode));
 
                 break;
             }
@@ -101,10 +112,11 @@ private void AddCommand(CliCommandInfo command, string[] commands)
 
     private CliCommandGroupNode? GetGroupNode(string[] commands)
     {
-        return GetGroupNode(_treeRootNodes, commands);
+        return GetGroupNode(null, _treeRootNodes, commands);
     }
 
-    private static CliCommandGroupNode? GetGroupNode(List<CliTreeNode> nodes, string[] cmds)
+    private static CliCommandGroupNode? GetGroupNode(CliCommandGroupNode? parent, List<CliTreeNode> nodes,
+        string[] cmds)
     {
         var childNode = nodes
             .OfType<CliCommandGroupNode>()
@@ -118,16 +130,16 @@ private void AddCommand(CliCommandInfo command, string[] commands)
 
         if (childNode != null)
         {
-            return GetGroupNode(childNode.ChildNodes, cmds.Skip(1).ToArray());
+            return GetGroupNode(childNode, childNode.ChildNodes, cmds.Skip(1).ToArray());
         }
 
-        var groupNode = new CliCommandGroupNode(cmds[0]);
+        var groupNode = new CliCommandGroupNode(cmds[0], parent);
 
         nodes.Add(groupNode);
 
         return cmds.Length == 1
             ? groupNode
-            : GetGroupNode(groupNode.ChildNodes, cmds.Skip(1).ToArray());
+            : GetGroupNode(groupNode, groupNode.ChildNodes, cmds.Skip(1).ToArray());
     }
 
     public IEnumerable<CliTreeNode> TreeRootNodes => _treeRootNodes;

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/CliTreeNode.cs

@@ -2,11 +2,11 @@
 
 namespace CreativeCoders.Cli.Hosting.Commands.Store;
 
-public class CliTreeNode(string name)
+public class CliTreeNode(string name, CliCommandGroupNode? parent)
 {
     public List<CliTreeNode> ChildNodes { get; } = new List<CliTreeNode>();
 
-    public CliCommandGroupNode? Parent { get; set; }
+    public CliCommandGroupNode? Parent { get; } = parent;
 
     public string Name { get; } = Ensure.IsNotNullOrWhitespace(name);
 }

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/FindCommandNodeResult.cs

@@ -0,0 +1,11 @@
+using CreativeCoders.Core;
+
+namespace CreativeCoders.Cli.Hosting.Commands.Store;
+
+public class FindCommandNodeResult<TNode>(TNode? node, string[] remainingArgs)
+    where TNode : CliTreeNode
+{
+    public TNode? Node { get; } = Ensure.NotNull(node);
+
+    public string[] RemainingArgs { get; } = Ensure.NotNull(remainingArgs);
+}

source/Cli/CreativeCoders.Cli.Hosting/Commands/Store/ICliCommandStore.cs

@@ -4,9 +4,9 @@ public interface ICliCommandStore
 {
     void AddCommands(IEnumerable<CliCommandInfo> commands);
 
-    CliCommandInfo? FindCommandForArgs(string[] args);
+    FindCommandNodeResult<CliCommandGroupNode>? FindCommandGroupNode(string[] args);
 
-    CliCommandGroupNode? FindGroupNodeForArgs(string[] args);
+    FindCommandNodeResult<CliCommandNode>? FindCommandNode(string[] args);
 
     IEnumerable<CliTreeNode> TreeRootNodes { get; }
 

source/Cli/CreativeCoders.Cli.Hosting/DefaultCliHost.cs

@@ -20,10 +20,11 @@ public DefaultCliHost(ICliCommandStore commandStore, IServiceProvider servicePro
 
     public async Task<CliResult> RunAsync(string[] args)
     {
-        var commandInfo = _commandStore.FindCommandForArgs(args);
-        if (commandInfo != null)
+        var commandInfo = _commandStore.FindCommandNode(args);
+        if (commandInfo?.Node?.CommandInfo != null)
         {
-            var command = commandInfo.CommandType.CreateInstance<ICliCommand>(_serviceProvider);
+            var command =
+                commandInfo.Node?.CommandInfo.CommandType.CreateInstance<ICliCommand>(_serviceProvider);
 
             if (command != null)
             {