Enable --interactive by default for sessions that are local.

This change unifies the `--interactive` infrastructure for all `dotnet` commands.
With that common infra, it also enables interactivity for non-CI scenarios by default.
We reuse CI detection from telemetry and from output redirection to determine whether to enable interactivity.

Author: baronfel

src/Cli/dotnet/CommonOptions.cs

@@ -116,12 +116,24 @@ public static CliArgument<string> DefaultToCurrentDirectory(this CliArgument<str
             Arity = ArgumentArity.Zero
         }.ForwardAs("-restore:false");
 
-        public static CliOption<bool> InteractiveMsBuildForwardOption =
-            new ForwardedOption<bool>("--interactive")
-            {
-                Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-                Arity = ArgumentArity.Zero
-            }.ForwardAs("-property:NuGetInteractive=true");
+        private static bool IsCIEnvironmentOrRedirected() =>
+            new Telemetry.CIEnvironmentDetectorForTelemetry().IsCIEnvironment() || Console.IsOutputRedirected;
+
+        /// <summary>
+        /// A 'template' for interactive usage across the whole dotnet CLI. Use this as a base and then specialize it for your use cases.
+        /// Despite being a 'forwarded option' there is no default forwarding configured, so if you want forwarding you can add it on a per-command basis.
+        /// </summary>
+        /// <remarks>If not set by a user, this will default to true if the user is not in a CI environment as detected by <see cref="Telemetry.CIEnvironmentDetectorForTelemetry.IsCIEnvironment"/>.</remarks>
+        public static ForwardedOption<bool> InteractiveOption() =>
+             new("--interactive")
+             {
+                 Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
+                 Arity = ArgumentArity.Zero,
+                 // this default is called when no tokens/options are passed on the CLI args
+                 DefaultValueFactory = (ar) => IsCIEnvironmentOrRedirected()
+             };
+
+        public static CliOption<bool> InteractiveMsBuildForwardOption = InteractiveOption().ForwardAsSingle(interactive => $"-property:NuGetInteractive={interactive}");
 
         public static CliOption<bool> DisableBuildServersOption =
             new ForwardedOption<bool>("--disable-build-servers")

src/Cli/dotnet/OptionForwardingExtensions.cs

@@ -5,15 +5,19 @@
 using System.CommandLine.Parsing;
 using System.CommandLine.StaticCompletions;
 
+#nullable enable
+
 namespace Microsoft.DotNet.Cli
 {
     public static class OptionForwardingExtensions
     {
-        public static ForwardedOption<T> Forward<T>(this ForwardedOption<T> option) => option.SetForwardingFunction((T o) => new string[] { option.Name });
+        public static ForwardedOption<T> Forward<T>(this ForwardedOption<T> option) => option.SetForwardingFunction((T? o) => [option.Name]);
+
+        public static ForwardedOption<T> ForwardAs<T>(this ForwardedOption<T> option, string value) => option.SetForwardingFunction((T? o) => [value]);
 
-        public static ForwardedOption<T> ForwardAs<T>(this ForwardedOption<T> option, string value) => option.SetForwardingFunction((T o) => new string[] { value });
+        public static ForwardedOption<T> ForwardAsSingle<T>(this ForwardedOption<T> option, Func<T?, string> format) => option.SetForwardingFunction(format);
 
-        public static ForwardedOption<T> ForwardAsSingle<T>(this ForwardedOption<T> option, Func<T, string> format) => option.SetForwardingFunction(format);
+        public static ForwardedOption<bool> ForwardIfEnabled(this ForwardedOption<bool> option, string value) => option.SetForwardingFunction((bool o) => o == true ? [value] : []);
 
         /// <summary>
         /// Set up an option to be forwaded as an output path to MSBuild
@@ -24,47 +28,60 @@ public static class OptionForwardingExtensions
         /// <returns>The option</returns>
         public static ForwardedOption<string> ForwardAsOutputPath(this ForwardedOption<string> option, string outputPropertyName, bool surroundWithDoubleQuotes = false)
         {
-            return option.SetForwardingFunction((string o) =>
+            return option.SetForwardingFunction((string? o) =>
             {
+                if (o is null)
+                {
+                    return [];
+                }
                 string argVal = CommandDirectoryContext.GetFullPath(o);
                 if (surroundWithDoubleQuotes)
                 {
                     //  Not sure if this is necessary, but this is what "dotnet test" previously did and so we are
                     //  preserving the behavior here after refactoring
                     argVal = TestCommandParser.SurroundWithDoubleQuotes(argVal);
                 }
-                return new string[]
-                {
+                return [
                     $"-property:{outputPropertyName}={argVal}",
                     "-property:_CommandLineDefinedOutputPath=true"
-                };
+                ];
             });
         }
 
         public static ForwardedOption<string[]> ForwardAsProperty(this ForwardedOption<string[]> option) => option
             .SetForwardingFunction((optionVals) =>
-                optionVals
+                (optionVals ?? [])
                     .SelectMany(Utils.MSBuildPropertyParser.ParseProperties)
                     .Select(keyValue => $"{option.Name}:{keyValue.key}={keyValue.value}")
                 );
 
-        public static CliOption<T> ForwardAsMany<T>(this ForwardedOption<T> option, Func<T, IEnumerable<string>> format) => option.SetForwardingFunction(format);
+        public static CliOption<T> ForwardAsMany<T>(this ForwardedOption<T> option, Func<T?, IEnumerable<string>> format) => option.SetForwardingFunction(format);
 
         public static CliOption<IEnumerable<string>> ForwardAsManyArgumentsEachPrefixedByOption(this ForwardedOption<IEnumerable<string>> option, string alias) => option.ForwardAsMany(o => ForwardedArguments(alias, o));
 
         public static IEnumerable<string> OptionValuesToBeForwarded(this ParseResult parseResult, CliCommand command) =>
             command.Options
                 .OfType<IForwardedOption>()
-                .SelectMany(o => o.GetForwardingFunction()(parseResult)) ?? Array.Empty<string>();
+                .Select(o => o.GetForwardingFunction())
+                .SelectMany(f => f is not null ? f(parseResult) : Array.Empty<string>());
 
 
-        public static IEnumerable<string> ForwardedOptionValues<T>(this ParseResult parseResult, CliCommand command, string alias) =>
-            command.Options?
+        public static IEnumerable<string> ForwardedOptionValues<T>(this ParseResult parseResult, CliCommand command, string alias)
+        {
+            var func = command.Options?
                 .Where(o => o.Name.Equals(alias) || o.Aliases.Contains(alias))?
                 .OfType<IForwardedOption>()?
                 .FirstOrDefault()?
-                .GetForwardingFunction()(parseResult)
-            ?? Array.Empty<string>();
+                .GetForwardingFunction();
+            if (func is not null)
+            {
+                return func(parseResult) ?? [];
+            }
+            else
+            {
+                return [];
+            }
+        }
 
         public static CliOption<T> AllowSingleArgPerToken<T>(this CliOption<T> option)
         {
@@ -94,9 +111,9 @@ public static CliOption<T> WithHelpDescription<T>(this CliOption<T> option, CliC
             return option;
         }
 
-        private static IEnumerable<string> ForwardedArguments(string alias, IEnumerable<string> arguments)
+        private static IEnumerable<string> ForwardedArguments(string alias, IEnumerable<string>? arguments)
         {
-            foreach (string arg in arguments)
+            foreach (string arg in arguments ?? [])
             {
                 yield return alias;
                 yield return arg;
@@ -113,34 +130,48 @@ public class ForwardedOption<T> : CliOption<T>, IForwardedOption
     {
         private Func<ParseResult, IEnumerable<string>> ForwardingFunction;
 
-        public ForwardedOption(string name, params string[] aliases) : base(name, aliases) { }
+        public ForwardedOption(string name, params string[] aliases) : base(name, aliases)
+        {
+            ForwardingFunction = _ => [];
+        }
 
-        public ForwardedOption(string name, Func<ArgumentResult, T> parseArgument, string description = null)
+        public ForwardedOption(string name, Func<ArgumentResult, T> parseArgument, string? description = null)
             : base(name)
         {
             CustomParser = parseArgument;
             Description = description;
+            ForwardingFunction = _ => [];
         }
 
-        public ForwardedOption<T> SetForwardingFunction(Func<T, IEnumerable<string>> func)
+        public ForwardedOption<T> SetForwardingFunction(Func<T?, IEnumerable<string>> func)
         {
             ForwardingFunction = GetForwardingFunction(func);
             return this;
         }
 
-        public ForwardedOption<T> SetForwardingFunction(Func<T, string> format)
+        public ForwardedOption<T> SetForwardingFunction(Func<T?, string> format)
         {
-            ForwardingFunction = GetForwardingFunction((o) => new string[] { format(o) });
+            ForwardingFunction = GetForwardingFunction((o) => [format(o)]);
             return this;
         }
 
-        public ForwardedOption<T> SetForwardingFunction(Func<T, ParseResult, IEnumerable<string>> func)
+        public ForwardedOption<T> SetForwardingFunction(Func<T?, ParseResult, IEnumerable<string>> func)
         {
-            ForwardingFunction = (ParseResult parseResult) => parseResult.GetResult(this) is not null ? func(parseResult.GetValue<T>(this), parseResult) : Array.Empty<string>();
+            ForwardingFunction = (ParseResult parseResult) =>
+            {
+                if (parseResult.GetResult(this) is OptionResult argresult && argresult.GetValue<T>(this) is T validValue)
+                {
+                    return func(validValue, parseResult) ?? [];
+                }
+                else
+                {
+                    return [];
+                }
+            };
             return this;
         }
 
-        public Func<ParseResult, IEnumerable<string>> GetForwardingFunction(Func<T, IEnumerable<string>> func)
+        public Func<ParseResult, IEnumerable<string>> GetForwardingFunction(Func<T?, IEnumerable<string>> func)
         {
             return (ParseResult parseResult) => parseResult.GetResult(this) is not null ? func(parseResult.GetValue<T>(this)) : Array.Empty<string>();
         }
@@ -153,7 +184,7 @@ public Func<ParseResult, IEnumerable<string>> GetForwardingFunction()
 
     public class DynamicForwardedOption<T> : ForwardedOption<T>, IDynamicOption
     {
-        public DynamicForwardedOption(string name, Func<ArgumentResult, T> parseArgument, string description = null)
+        public DynamicForwardedOption(string name, Func<ArgumentResult, T> parseArgument, string? description = null)
             : base(name, parseArgument, description)
         {
         }

src/Cli/dotnet/commands/dotnet-nuget/NuGetCommandParser.cs

@@ -64,7 +64,7 @@ private static CliCommand GetDeleteCommand()
             {
                 Arity = ArgumentArity.Zero
             });
-            deleteCommand.Options.Add(new CliOption<bool>("--interactive"));
+            deleteCommand.Options.Add(CommonOptions.InteractiveOption());
 
             deleteCommand.SetAction(NuGetCommand.Run);
 
@@ -125,7 +125,7 @@ private static CliCommand GetPushCommand()
             {
                 Arity = ArgumentArity.Zero
             });
-            pushCommand.Options.Add(new CliOption<bool>("--interactive"));
+            pushCommand.Options.Add(CommonOptions.InteractiveOption());
             pushCommand.Options.Add(new CliOption<bool>("--skip-duplicate")
             {
                 Arity = ArgumentArity.Zero

src/Cli/dotnet/commands/dotnet-package/add/PackageAddCommandParser.cs

@@ -70,11 +70,7 @@ internal static class PackageAddCommandParser
             HelpName = LocalizableStrings.CmdPackageDirectory
         }.ForwardAsSingle(o => $"--package-directory {o}");
 
-        public static readonly CliOption<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
-        {
-            Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("--interactive");
+        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
         public static readonly CliOption<bool> PrereleaseOption = new ForwardedOption<bool>("--prerelease")
         {

src/Cli/dotnet/commands/dotnet-package/list/PackageListCommandParser.cs

@@ -72,11 +72,7 @@ internal static class PackageListCommandParser
         }.ForwardAsManyArgumentsEachPrefixedByOption("--source")
         .AllowSingleArgPerToken();
 
-        public static readonly CliOption InteractiveOption = new ForwardedOption<bool>("--interactive")
-        {
-            Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("--interactive");
+        public static readonly CliOption InteractiveOption = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
         public static readonly CliOption VerbosityOption = new ForwardedOption<VerbosityOptions>("--verbosity", "-v")
         {

src/Cli/dotnet/commands/dotnet-package/remove/PackageRemoveCommandParser.cs

@@ -15,11 +15,7 @@ internal static class PackageRemoveCommandParser
             Arity = ArgumentArity.OneOrMore,
         };
 
-        public static readonly CliOption<bool> InteractiveOption = new ForwardedOption<bool>("--interactive")
-        {
-            Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("--interactive");
+        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
         private static readonly CliCommand Command = ConstructCommand();
 

src/Cli/dotnet/commands/dotnet-package/search/PackageSearchCommandParser.cs

@@ -40,11 +40,7 @@ internal static class PackageSearchCommandParser
             Arity = ArgumentArity.Zero
         }.ForwardAs("--exact-match");
 
-        public static readonly CliOption<bool> Interactive = new ForwardedOption<bool>("--interactive")
-        {
-            Description = LocalizableStrings.InteractiveDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs("--interactive");
+        public static readonly CliOption<bool> Interactive = CommonOptions.InteractiveOption().ForwardIfEnabled("--interactive");
 
         public static readonly CliOption<bool> Prerelease = new ForwardedOption<bool>("--prerelease")
         {

src/Cli/dotnet/commands/dotnet-reference/dotnet-reference-add/ReferenceAddCommandParser.cs

@@ -30,7 +30,7 @@ internal static class ReferenceAddCommandParser
 
         }.AddCompletions(Complete.TargetFrameworksFromProjectFile);
 
-        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveMsBuildForwardOption;
+        public static readonly CliOption<bool> InteractiveOption = CommonOptions.InteractiveOption();
 
         private static readonly CliCommand Command = ConstructCommand();
 

src/Cli/dotnet/commands/dotnet-tool/ToolCommandRestorePassThroughOptions.cs

@@ -35,10 +35,6 @@ internal static class ToolCommandRestorePassThroughOptions
             Arity = ArgumentArity.Zero
         }.ForwardAs("--ignore-failed-sources");
 
-        public static CliOption<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
-        {
-            Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-            Arity = ArgumentArity.Zero
-        }.ForwardAs(Constants.RestoreInteractiveOption);
+        public static CliOption<bool> InteractiveRestoreOption = CommonOptions.InteractiveOption().ForwardIfEnabled(Constants.RestoreInteractiveOption);
     }
 }

src/Cli/dotnet/commands/dotnet-workload/WorkloadCommandNuGetRestoreActionConfigOptions.cs

@@ -35,10 +35,7 @@ internal static class WorkloadCommandNuGetRestoreActionConfigOptions
             Arity = ArgumentArity.Zero
         };
 
-        public static CliOption<bool> InteractiveRestoreOption = new ForwardedOption<bool>("--interactive")
-        {
-            Description = CommonLocalizableStrings.CommandInteractiveOptionDescription,
-        };
+        public static CliOption<bool> InteractiveRestoreOption = CommonOptions.InteractiveOption();
 
         public static CliOption<bool> HiddenDisableParallelOption = new ForwardedOption<bool>("--disable-parallel")
         {