Add custom argument parsing for verbs

Introduces a `CustomArgumentParsingAttribute` to enable verbs without properties to ignore unknown arguments. This helps commands that manually parse arguments. Updates unit tests to reflect this new functionality.

Author: neoscie

Neolution.DotNet.Console.UnitTests/DotNetConsoleEnvironmentTests.cs

@@ -32,7 +32,9 @@ public async Task GivenEnvironmentNameEnvironmentVariable_WhenRunningConsoleApp_
             Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", environmentName);
 
             const string commandLineString = "default";
-            var builder = DotNetConsole.CreateBuilderWithReference(Assembly.GetAssembly(typeof(DefaultCommand))!, commandLineString.Split(" "));
+            var servicesAssembly = Assembly.GetAssembly(typeof(DefaultCommand))!;
+            var verbTypes = new[] { typeof(DefaultOptions), typeof(EchoOptions) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, commandLineString.Split(" "));
 
             if (builder.Environment.IsDevelopment())
             {

Neolution.DotNet.Console.UnitTests/DotNetConsoleGrammarTests.cs

@@ -188,7 +188,9 @@ public async Task GivenBuiltConsoleAppWithDefaultVerbWithoutProperties_WhenCalli
         /// <returns>A built console app ready to run.</returns>
         private static IDotNetConsole CreateConsoleAppWithLogger(string args, IUnitTestLogger tracker)
         {
-            var builder = DotNetConsole.CreateBuilderWithReference(Assembly.GetAssembly(typeof(DefaultCommand))!, args.Split(" "));
+            var servicesAssembly = Assembly.GetAssembly(typeof(DefaultCommand))!;
+            var verbTypes = new[] { typeof(DefaultOptions), typeof(EchoOptions) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, args.Split(" "));
 
             builder.Services.Replace(new ServiceDescriptor(typeof(IUnitTestLogger), tracker));
 

Neolution.DotNet.Console.UnitTests/Fakes/DefaultOptionsWithoutProperties.cs

@@ -1,13 +1,15 @@
 namespace Neolution.DotNet.Console.UnitTests.Fakes
 {
     using CommandLine;
+    using Neolution.DotNet.Console.Attributes;
 
     /// <summary>
-    /// The options stub for the <see cref="DefaultCommandWithoutProperties"/> - simulates customer scenario where options have no properties
+    /// The options stub for the <see cref="DefaultCommandWithoutProperties"/> - simulates scenario where options have none or are ignoring properties
     /// </summary>
     [Verb("default-no-props", isDefault: true)]
+    [CustomArgumentParsing]
     public class DefaultOptionsWithoutProperties
     {
-        // No properties defined - customers parse manually in the command
+        // No properties defined, options may be parsed manually in the command
     }
 }

Neolution.DotNet.Console/Attributes/CustomArgumentParsingAttribute.cs

@@ -0,0 +1,14 @@
+namespace Neolution.DotNet.Console.Attributes
+{
+    using System;
+
+    /// <summary>
+    /// Indicates that this verb options class uses custom argument parsing.
+    /// When applied, the CommandLineParser will not fail on arguments that are not mapped to Option or Value attributes,
+    /// allowing your command implementation to manually parse command-line arguments.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public sealed class CustomArgumentParsingAttribute : Attribute
+    {
+    }
+}

Neolution.DotNet.Console/Internal/CommandLineProcessor.cs

@@ -4,6 +4,7 @@
     using System.Linq;
     using System.Reflection;
     using CommandLine;
+    using Neolution.DotNet.Console.Attributes;
 
     /// <summary>
     /// Handles command line argument parsing and validation.
@@ -27,6 +28,18 @@ public static ParserResult<object> ParseArguments(Assembly assembly, Type[]? ver
                 CheckStrictVerbMatching(args, verbTypes);
             }
 
+            // Check if any verb type is marked for custom argument parsing
+            // This supports customers who manually parse arguments in their command
+            if (HasCustomArgumentParsing(verbTypes))
+            {
+                using var parser = new Parser(settings =>
+                {
+                    settings.IgnoreUnknownArguments = true;
+                    settings.CaseSensitive = false;
+                });
+                return parser.ParseArguments(args, verbTypes);
+            }
+
             return Parser.Default.ParseArguments(args, verbTypes);
         }
 
@@ -86,5 +99,15 @@ private static void CheckStrictVerbMatching(string[] args, Type[] availableVerbT
                 throw new DotNetConsoleException($"Cannot create builder, because the specified verb '{firstVerb}' matches no command.");
             }
         }
+
+        /// <summary>
+        /// Determines if any verb type has the CustomArgumentParsing attribute.
+        /// </summary>
+        /// <param name="verbTypes">The available verb types.</param>
+        /// <returns>True if any verb type uses custom argument parsing, false otherwise.</returns>
+        private static bool HasCustomArgumentParsing(Type[] verbTypes)
+        {
+            return verbTypes.Any(t => t.GetCustomAttribute<CustomArgumentParsingAttribute>() != null);
+        }
     }
 }