Upgrade System.CommandLine

sakno · sakno · commit ca3cbceff346 · 2025-10-22T12:11:17.000+03:00
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.Actions.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.Actions.cs
@@ -20,9 +20,11 @@ public abstract class SynchronousAction : SynchronousCommandLineAction
 
         /// <inheritdoc />
         public sealed override int Invoke(ParseResult result)
-            => result.Configuration is CommandContext context ? Invoke(context.Session, result) : -1;
+            => CommandContext.TryGetSession(result) is { } session
+                ? Invoke(session, result)
+                : CommandContext.GenericErrorExitCode;
     }
-    
+
     private sealed class DelegatingSynchronousAction(Action<IMaintenanceSession, ParseResult> action) : SynchronousAction
     {
         protected override int Invoke(IMaintenanceSession session, ParseResult result)
@@ -31,7 +33,7 @@ protected override int Invoke(IMaintenanceSession session, ParseResult result)
             return 0;
         }
     }
-    
+
     /// <summary>
     /// Represents asynchronous command handler.
     /// </summary>
@@ -48,7 +50,9 @@ public abstract class AsynchronousAction : AsynchronousCommandLineAction
 
         /// <inheritdoc />
         public override Task<int> InvokeAsync(ParseResult result, CancellationToken token = default)
-            => result.Configuration is CommandContext context ? InvokeAsync(context.Session, result, token) : Task.FromResult(-1);
+            => CommandContext.TryGetSession(result) is { } session
+                ? InvokeAsync(session, result, token)
+                : Task.FromResult(CommandContext.GenericErrorExitCode);
     }
 
     private sealed class DelegatingAsynchronousAction(Func<IMaintenanceSession, ParseResult, CancellationToken, ValueTask> action)
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.HelpCommand.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.HelpCommand.cs
@@ -25,8 +25,7 @@ public static ApplicationMaintenanceCommand HelpCommand()
 file static class HelpOptionExtensions
 {
     public static int Invoke(this HelpOption option, ParseResult result)
-    {
-        var root = result.RootCommandResult;
-        return result.Configuration.Invoke(option.Name);
-    }
+        => result.RootCommandResult.Command is RootCommand root
+            ? root.Parse(option.Name).Invoke(result.InvocationConfiguration)
+            : CommandContext.GenericErrorExitCode;
 }
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.InteractiveCommand.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.InteractiveCommand.cs
@@ -20,10 +20,11 @@ public static ApplicationMaintenanceCommand EnterInteractiveModeCommand()
 
         static Task EnterInteractiveMode(ParseResult result, CancellationToken token)
         {
-            if (result.Configuration is CommandContext context)
-                context.Session.IsInteractive = true;
+            // TODO: Replace with null-conditional assignment
+            if (CommandContext.TryGetSession(result) is { } session)
+                session.IsInteractive = true;
 
-            return result.Configuration.Output.WriteLineAsync(
+            return result.InvocationConfiguration.Output.WriteLineAsync(
                 CommandResources.WelcomeMessage(RootCommand.ExecutableName).AsMemory(),
                 token);
         }
@@ -42,8 +43,8 @@ public static ApplicationMaintenanceCommand LeaveInteractiveModeCommand()
 
         command.SetAction(static result =>
         {
-            if (result.Configuration is CommandContext context)
-                context.Session.IsInteractive = false;
+            if (CommandContext.TryGetSession(result) is { } session)
+                session.IsInteractive = false;
         });
         
         return command;
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.Probe.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/ApplicationMaintenanceCommand.Probe.cs
@@ -77,7 +77,7 @@ Task InvokeAsync(ParseResult result, CancellationToken token) => provider.Invoke
             result.GetRequiredValue(successfulResponseOption),
             result.GetRequiredValue(failedResponseOption),
             result.GetRequiredValue(timeoutArg),
-            result.Configuration.Output,
+            result.InvocationConfiguration.Output,
             token
         );
     }
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandContext.Directives.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandContext.Directives.cs
@@ -5,20 +5,16 @@ namespace DotNext.Maintenance.CommandLine;
 
 partial class CommandContext
 {
-    private sealed class DirectiveAction : SynchronousCommandLineAction
+    private sealed class DirectiveAction(Action<CommandContext> action) : SynchronousCommandLineAction
     {
-        internal readonly Action<CommandContext> Action;
+        internal Action<CommandContext> Action => action;
 
-        public DirectiveAction(Action<CommandContext> action)
-        {
-            Action = action;
-            Terminating = false;
-        }
+        public override bool Terminating => false;
 
         public override int Invoke(ParseResult parseResult)
         {
             int result;
-            if (parseResult.Configuration is CommandContext context)
+            if (parseResult.InvocationConfiguration is CommandContext context)
             {
                 Action(context);
                 result = 0;
@@ -38,9 +34,7 @@ private sealed class PrintErrorCodeDirective : Directive
 
         public PrintErrorCodeDirective()
             : base(Name)
-        {
-            Action = new DirectiveAction(static context => context.printExitCode = true);
-        }
+            => Action = new DirectiveAction(static context => context.printExitCode = true);
     }
     
     private sealed class SuppressStandardOutputDirective : Directive
@@ -49,9 +43,7 @@ private sealed class SuppressStandardOutputDirective : Directive
 
         public SuppressStandardOutputDirective()
             : base(Name)
-        {
-            Action = new DirectiveAction(static context => context.suppressOutputBuffer = true);
-        }
+            => Action = new DirectiveAction(static context => context.suppressOutputBuffer = true);
     }
     
     private sealed class SuppressStandardErrorDirective : Directive
@@ -60,9 +52,7 @@ private sealed class SuppressStandardErrorDirective : Directive
 
         public SuppressStandardErrorDirective()
             : base(Name)
-        {
-            Action = new DirectiveAction(static context => context.suppressErrorBuffer = true);
-        }
+            => Action = new DirectiveAction(static context => context.suppressErrorBuffer = true);
     }
 
     internal static void RegisterDirectives(RootCommand root)
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandContext.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandContext.cs
@@ -12,8 +12,9 @@ namespace DotNext.Maintenance.CommandLine;
 /// <summary>
 /// Represents command invocation context.
 /// </summary>
-internal sealed partial class CommandContext : CommandLineConfiguration
+internal sealed partial class CommandContext : InvocationConfiguration
 {
+    public const int GenericErrorExitCode = -1;
     private const int InvalidArgumentExitCode = 64; // EX_USAGE from sysexits.h
     private const int ForbiddenExitCode = 77; // EX_NOPERM
     
@@ -24,10 +25,8 @@ internal sealed partial class CommandContext : CommandLineConfiguration
     private bool suppressOutputBuffer;
     private bool suppressErrorBuffer;
     
-    internal CommandContext(RootCommand root, IMaintenanceSession session)
-        : base(root)
+    internal CommandContext(IMaintenanceSession session)
     {
-        Debug.Assert(root is not null);
         Debug.Assert(session is not null);
 
         Session = session;
@@ -40,35 +39,37 @@ internal CommandContext(RootCommand root, IMaintenanceSession session)
     /// </summary>
     public IMaintenanceSession Session { get; }
 
-    internal async ValueTask<int> InvokeAsync(string input,
+    internal async ValueTask<int> InvokeAsync(RootCommand root,
+        string input,
+        ParserConfiguration configuration,
         IAuthenticationHandler? authentication,
         AuthorizationCallback? authorization,
         CancellationToken token)
     {
         int exitCode;
-        var result = Parse(input);
+        var result = root.Parse(input, configuration);
         
         if (result.Errors is { Count: > 0 } errors)
         {
-            exitCode = ProcessParseErrors(errors, result.Tokens);
+            exitCode = ProcessParseErrors(root, errors, result.Tokens);
         }
         else if (await AuthenticateAsync(Session, result, authentication, token).ConfigureAwait(false)
                  && await authorization.AuthorizeAsync(Session, result.CommandResult, token).ConfigureAwait(false)
                  && await AuthorizeAsync(Session, result.CommandResult, token).ConfigureAwait(false))
         {
-            exitCode = await result.InvokeAsync(token).ConfigureAwait(false);
+            exitCode = await result.InvokeAsync(this, token).ConfigureAwait(false);
         }
         else
         {
-            exitCode = Forbid(result.Tokens);
+            exitCode = Forbid(root, result.Tokens);
         }
 
         return exitCode;
     }
 
-    private void ExecuteDirectives(IEnumerable<Token> tokens)
+    private void ExecuteDirectives(RootCommand root, IEnumerable<Token> tokens)
     {
-        var actions = from directive in (RootCommand as RootCommand)?.Directives ?? []
+        var actions = from directive in root.Directives
             from token in tokens
             where Matches(token, directive)
             let action = (directive.Action as DirectiveAction)?.Action
@@ -141,9 +142,9 @@ internal void Exit(int exitCode, BufferWriter<char> output, BufferWriter<char> e
         }
     }
 
-    private int ProcessParseErrors(IReadOnlyList<ParseError> errors, IReadOnlyList<Token> tokens)
+    private int ProcessParseErrors(RootCommand root, IReadOnlyList<ParseError> errors, IReadOnlyList<Token> tokens)
     {
-        ExecuteDirectives(tokens);
+        ExecuteDirectives(root, tokens);
         
         foreach (var parseError in errors)
         {
@@ -153,13 +154,13 @@ private int ProcessParseErrors(IReadOnlyList<ParseError> errors, IReadOnlyList<T
         return InvalidArgumentExitCode;
     }
 
-    private int Forbid(IReadOnlyList<Token> tokens)
+    private int Forbid(RootCommand root, IReadOnlyList<Token> tokens)
     {
-        ExecuteDirectives(tokens);
+        ExecuteDirectives(root, tokens);
         Error.WriteLine(CommandResources.AccessDenied);
         return ForbiddenExitCode;
     }
 
     internal static IMaintenanceSession? TryGetSession(ParseResult result)
-        => (result.Configuration as CommandContext)?.Session;
+        => (result.InvocationConfiguration as CommandContext)?.Session;
 }
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandLineMaintenanceInterfaceHost.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/CommandLineMaintenanceInterfaceHost.cs
@@ -23,6 +23,7 @@ public sealed class CommandLineMaintenanceInterfaceHost : ApplicationMaintenance
     private readonly RootCommand root;
     private readonly IAuthenticationHandler? authentication;
     private readonly AuthorizationCallback? authorization;
+    private readonly ParserConfiguration configuration;
 
     /// <summary>
     /// Initializes a new host.
@@ -31,17 +32,22 @@ public sealed class CommandLineMaintenanceInterfaceHost : ApplicationMaintenance
     /// <param name="commands">A set of commands to be available for execution.</param>
     /// <param name="authentication">Optional authentication handler.</param>
     /// <param name="authorization">A set of global authorization rules to be applied to all commands.</param>
+    /// <param name="configuration">Command-line parser configuration.</param>
     /// <param name="loggerFactory">Optional logger factory.</param>
     public CommandLineMaintenanceInterfaceHost(
         UnixDomainSocketEndPoint endPoint,
         IEnumerable<ApplicationMaintenanceCommand> commands,
         IAuthenticationHandler? authentication = null,
         AuthorizationCallback? authorization = null,
+        ParserConfiguration? configuration = null,
         ILoggerFactory? loggerFactory = null)
         : base(endPoint, loggerFactory)
     {
-        root = new RootCommand(RootCommand.ExecutableName + " Maintenance Interface");
-        root.Action = new MyAction();
+        root = new(RootCommand.ExecutableName + " Maintenance Interface")
+        {
+            Action = new MyAction()
+        };
+        
         foreach (var subCommand in commands)
             root.Add(subCommand);
 
@@ -52,15 +58,13 @@ public CommandLineMaintenanceInterfaceHost(
 
         this.authentication = authentication;
         this.authorization = authorization;
+        this.configuration = configuration ?? new();
     }
     
     private sealed class MyAction : SynchronousCommandLineAction
     {
-        public MyAction()
-        {
-            Terminating = false;
-        }
-        
+        public override bool Terminating => false;
+
         public override int Invoke(ParseResult parseResult)
         {
             return 0;
@@ -74,10 +78,12 @@ protected override async ValueTask ExecuteCommandAsync(IMaintenanceSession sessi
         var error = new PoolingBufferWriter<char>(CharBufferAllocator) { Capacity = BufferSize };
         var outputWriter = output.AsTextWriter();
         var errorWriter = error.AsTextWriter();
-        var context = new CommandContext(root, session) { Error = errorWriter, Output = outputWriter };
+        var context = new CommandContext(session) { Error = errorWriter, Output = outputWriter };
         try
         {
-            var exitCode = await context.InvokeAsync(command.ToString(), authentication, authorization, token).ConfigureAwait(false);
+            var exitCode = await context
+                .InvokeAsync(root, command.ToString(), configuration, authentication, authorization, token)
+                .ConfigureAwait(false);
             context.Exit(exitCode, output, error);
         }
         catch (Exception e)
diff --git a/src/DotNext.MaintenanceServices/Maintenance/CommandLine/HostingServices.cs b/src/DotNext.MaintenanceServices/Maintenance/CommandLine/HostingServices.cs
@@ -1,3 +1,4 @@
+using System.CommandLine;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
@@ -148,5 +149,11 @@ public static IServiceCollection UseApplicationMaintenanceInterface(this IServic
         => services.AddSingleton<IHostedService, CommandLineMaintenanceInterfaceHost>(unixDomainSocketPath.CreateHost);
 
     private static CommandLineMaintenanceInterfaceHost CreateHost(this string unixDomainSocketPath, IServiceProvider services)
-        => new(new(unixDomainSocketPath), services.GetServices<ApplicationMaintenanceCommand>(), authentication: services.GetService<IAuthenticationHandler>(), authorization: Delegate.Combine(services.GetServices<AuthorizationCallback>().ToArray()) as AuthorizationCallback, loggerFactory: services.GetService<ILoggerFactory>());
+        => new(
+            new(unixDomainSocketPath),
+            services.GetServices<ApplicationMaintenanceCommand>(),
+            authentication: services.GetService<IAuthenticationHandler>(),
+            authorization: Delegate.Combine(services.GetServices<AuthorizationCallback>().ToArray()) as AuthorizationCallback,
+            configuration: services.GetService<ParserConfiguration>(),
+            loggerFactory: services.GetService<ILoggerFactory>());
 }
diff --git a/src/DotNext.Tests/Maintenance/CommandLine/CommandLineMaintenanceInterfaceHostTests.cs b/src/DotNext.Tests/Maintenance/CommandLine/CommandLineMaintenanceInterfaceHostTests.cs
@@ -73,7 +73,7 @@ public static async Task UdsEndpointAuthentication()
                             True(session.Identity.IsAuthenticated);
                             var identity = IsType<LinuxUdsPeerIdentity>(session.Identity);
                             Equal(Environment.UserName, identity.Name);
-                            result.Configuration.Output.Write(identity.ProcessId);
+                            result.InvocationConfiguration.Output.Write(identity.ProcessId);
                         });
                     });
             })
@@ -131,7 +131,7 @@ public static async Task PasswordAuthentication(string request, string response)
                         {
                             var x = result.GetRequiredValue(argX);
                             var y = result.GetRequiredValue(argY);
-                            return new(result.Configuration.Output.WriteAsync((x + y).ToString().AsMemory(), token));
+                            return new(result.InvocationConfiguration.Output.WriteAsync((x + y).ToString().AsMemory(), token));
                         });
                         cmd.Authorization += static (user, _, _, _) => new(user.IsInRole("role2"));
                     });
diff --git a/src/examples/CommandLineAMI/Program.cs b/src/examples/CommandLineAMI/Program.cs
@@ -40,7 +40,7 @@ static void ConfigureAddCommand(ApplicationMaintenanceCommand command)
     {
         var x = result.GetRequiredValue(argX);
         var y = result.GetRequiredValue(argY);
-        result.Configuration.Output.WriteLine(x + y);
+        result.InvocationConfiguration.Output.WriteLine(x + y);
     });
 }
 
@@ -66,7 +66,7 @@ static void ConfigureSubtractCommand(ApplicationMaintenanceCommand command)
     {
         var x = result.GetRequiredValue(argX);
         var y = result.GetRequiredValue(argY);
-        result.Configuration.Output.WriteLine(x - y);
+        result.InvocationConfiguration.Output.WriteLine(x - y);
     });
 }
 

Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,11 @@ public abstract class SynchronousAction : SynchronousCommandLineAction`
`20`	`20`
`21`	`21`	`/// <inheritdoc />`
`22`	`22`	`public sealed override int Invoke(ParseResult result)`
`23`		`- => result.Configuration is CommandContext context ? Invoke(context.Session, result) : -1;`
	`23`	`+ => CommandContext.TryGetSession(result) is { } session`
	`24`	`+ ? Invoke(session, result)`
	`25`	`+ : CommandContext.GenericErrorExitCode;`
`24`	`26`	`}`
`25`		`-`
	`27`	`+`
`26`	`28`	`private sealed class DelegatingSynchronousAction(Action<IMaintenanceSession, ParseResult> action) : SynchronousAction`
`27`	`29`	`{`
`28`	`30`	`protected override int Invoke(IMaintenanceSession session, ParseResult result)`
`@@ -31,7 +33,7 @@ protected override int Invoke(IMaintenanceSession session, ParseResult result)`
`31`	`33`	`return 0;`
`32`	`34`	`}`
`33`	`35`	`}`
`34`		`-`
	`36`	`+`
`35`	`37`	`/// <summary>`
`36`	`38`	`/// Represents asynchronous command handler.`
`37`	`39`	`/// </summary>`
`@@ -48,7 +50,9 @@ public abstract class AsynchronousAction : AsynchronousCommandLineAction`
`48`	`50`
`49`	`51`	`/// <inheritdoc />`
`50`	`52`	`public override Task<int> InvokeAsync(ParseResult result, CancellationToken token = default)`
`51`		`- => result.Configuration is CommandContext context ? InvokeAsync(context.Session, result, token) : Task.FromResult(-1);`
	`53`	`+ => CommandContext.TryGetSession(result) is { } session`
	`54`	`+ ? InvokeAsync(session, result, token)`
	`55`	`+ : Task.FromResult(CommandContext.GenericErrorExitCode);`
`52`	`56`	`}`
`53`	`57`
`54`	`58`	`private sealed class DelegatingAsynchronousAction(Func<IMaintenanceSession, ParseResult, CancellationToken, ValueTask> action)`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,7 @@ public static ApplicationMaintenanceCommand HelpCommand()`
`25`	`25`	`file static class HelpOptionExtensions`
`26`	`26`	`{`
`27`	`27`	`public static int Invoke(this HelpOption option, ParseResult result)`
`28`		`- {`
`29`		`- var root = result.RootCommandResult;`
`30`		`- return result.Configuration.Invoke(option.Name);`
`31`		`- }`
	`28`	`+ => result.RootCommandResult.Command is RootCommand root`
	`29`	`+ ? root.Parse(option.Name).Invoke(result.InvocationConfiguration)`
	`30`	`+ : CommandContext.GenericErrorExitCode;`
`32`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ Task InvokeAsync(ParseResult result, CancellationToken token) => provider.Invoke`
`77`	`77`	`result.GetRequiredValue(successfulResponseOption),`
`78`	`78`	`result.GetRequiredValue(failedResponseOption),`
`79`	`79`	`result.GetRequiredValue(timeoutArg),`
`80`		`- result.Configuration.Output,`
	`80`	`+ result.InvocationConfiguration.Output,`
`81`	`81`	`token`
`82`	`82`	`);`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,9 @@ namespace DotNext.Maintenance.CommandLine;`
`12`	`12`	`/// <summary>`
`13`	`13`	`/// Represents command invocation context.`
`14`	`14`	`/// </summary>`
`15`		`-internal sealed partial class CommandContext : CommandLineConfiguration`
	`15`	`+internal sealed partial class CommandContext : InvocationConfiguration`
`16`	`16`	`{`
	`17`	`+ public const int GenericErrorExitCode = -1;`
`17`	`18`	`private const int InvalidArgumentExitCode = 64; // EX_USAGE from sysexits.h`
`18`	`19`	`private const int ForbiddenExitCode = 77; // EX_NOPERM`
`19`	`20`
`@@ -24,10 +25,8 @@ internal sealed partial class CommandContext : CommandLineConfiguration`
`24`	`25`	`private bool suppressOutputBuffer;`
`25`	`26`	`private bool suppressErrorBuffer;`
`26`	`27`
`27`		`- internal CommandContext(RootCommand root, IMaintenanceSession session)`
`28`		`- : base(root)`
	`28`	`+ internal CommandContext(IMaintenanceSession session)`
`29`	`29`	`{`
`30`		`- Debug.Assert(root is not null);`
`31`	`30`	`Debug.Assert(session is not null);`
`32`	`31`
`33`	`32`	`Session = session;`
`@@ -40,35 +39,37 @@ internal CommandContext(RootCommand root, IMaintenanceSession session)`
`40`	`39`	`/// </summary>`
`41`	`40`	`public IMaintenanceSession Session { get; }`
`42`	`41`
`43`		`- internal async ValueTask<int> InvokeAsync(string input,`
	`42`	`+ internal async ValueTask<int> InvokeAsync(RootCommand root,`
	`43`	`+ string input,`
	`44`	`+ ParserConfiguration configuration,`
`44`	`45`	`IAuthenticationHandler? authentication,`
`45`	`46`	`AuthorizationCallback? authorization,`
`46`	`47`	`CancellationToken token)`
`47`	`48`	`{`
`48`	`49`	`int exitCode;`
`49`		`- var result = Parse(input);`
	`50`	`+ var result = root.Parse(input, configuration);`
`50`	`51`
`51`	`52`	`if (result.Errors is { Count: > 0 } errors)`
`52`	`53`	`{`
`53`		`- exitCode = ProcessParseErrors(errors, result.Tokens);`
	`54`	`+ exitCode = ProcessParseErrors(root, errors, result.Tokens);`
`54`	`55`	`}`
`55`	`56`	`else if (await AuthenticateAsync(Session, result, authentication, token).ConfigureAwait(false)`
`56`	`57`	`&& await authorization.AuthorizeAsync(Session, result.CommandResult, token).ConfigureAwait(false)`
`57`	`58`	`&& await AuthorizeAsync(Session, result.CommandResult, token).ConfigureAwait(false))`
`58`	`59`	`{`
`59`		`- exitCode = await result.InvokeAsync(token).ConfigureAwait(false);`
	`60`	`+ exitCode = await result.InvokeAsync(this, token).ConfigureAwait(false);`
`60`	`61`	`}`
`61`	`62`	`else`
`62`	`63`	`{`
`63`		`- exitCode = Forbid(result.Tokens);`
	`64`	`+ exitCode = Forbid(root, result.Tokens);`
`64`	`65`	`}`
`65`	`66`
`66`	`67`	`return exitCode;`
`67`	`68`	`}`
`68`	`69`
`69`		`- private void ExecuteDirectives(IEnumerable<Token> tokens)`
	`70`	`+ private void ExecuteDirectives(RootCommand root, IEnumerable<Token> tokens)`
`70`	`71`	`{`
`71`		`- var actions = from directive in (RootCommand as RootCommand)?.Directives ?? []`
	`72`	`+ var actions = from directive in root.Directives`
`72`	`73`	`from token in tokens`
`73`	`74`	`where Matches(token, directive)`
`74`	`75`	`let action = (directive.Action as DirectiveAction)?.Action`
`@@ -141,9 +142,9 @@ internal void Exit(int exitCode, BufferWriter<char> output, BufferWriter<char> e`
`141`	`142`	`}`
`142`	`143`	`}`
`143`	`144`
`144`		`- private int ProcessParseErrors(IReadOnlyList<ParseError> errors, IReadOnlyList<Token> tokens)`
	`145`	`+ private int ProcessParseErrors(RootCommand root, IReadOnlyList<ParseError> errors, IReadOnlyList<Token> tokens)`
`145`	`146`	`{`
`146`		`- ExecuteDirectives(tokens);`
	`147`	`+ ExecuteDirectives(root, tokens);`
`147`	`148`
`148`	`149`	`foreach (var parseError in errors)`
`149`	`150`	`{`
`@@ -153,13 +154,13 @@ private int ProcessParseErrors(IReadOnlyList<ParseError> errors, IReadOnlyList<T`
`153`	`154`	`return InvalidArgumentExitCode;`
`154`	`155`	`}`
`155`	`156`
`156`		`- private int Forbid(IReadOnlyList<Token> tokens)`
	`157`	`+ private int Forbid(RootCommand root, IReadOnlyList<Token> tokens)`
`157`	`158`	`{`
`158`		`- ExecuteDirectives(tokens);`
	`159`	`+ ExecuteDirectives(root, tokens);`
`159`	`160`	`Error.WriteLine(CommandResources.AccessDenied);`
`160`	`161`	`return ForbiddenExitCode;`
`161`	`162`	`}`
`162`	`163`
`163`	`164`	`internal static IMaintenanceSession? TryGetSession(ParseResult result)`
`164`		`- => (result.Configuration as CommandContext)?.Session;`
	`165`	`+ => (result.InvocationConfiguration as CommandContext)?.Session;`
`165`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ static void ConfigureAddCommand(ApplicationMaintenanceCommand command)`
`40`	`40`	`{`
`41`	`41`	`var x = result.GetRequiredValue(argX);`
`42`	`42`	`var y = result.GetRequiredValue(argY);`
`43`		`- result.Configuration.Output.WriteLine(x + y);`
	`43`	`+ result.InvocationConfiguration.Output.WriteLine(x + y);`
`44`	`44`	`});`
`45`	`45`	`}`
`46`	`46`
`@@ -66,7 +66,7 @@ static void ConfigureSubtractCommand(ApplicationMaintenanceCommand command)`
`66`	`66`	`{`
`67`	`67`	`var x = result.GetRequiredValue(argX);`
`68`	`68`	`var y = result.GetRequiredValue(argY);`
`69`		`- result.Configuration.Output.WriteLine(x - y);`
	`69`	`+ result.InvocationConfiguration.Output.WriteLine(x - y);`
`70`	`70`	`});`
`71`	`71`	`}`
`72`	`72`