Implementing dotnet pack with nuspec files (#49813)

adds support for packing NuGet packages directly from a .nuspec file using the dotnet pack command without needing a csproj file

Author: kfikadu

src/Cli/dotnet/CliStrings.resx

@@ -823,4 +823,7 @@ The default is 'false.' However, when targeting .NET 7 or lower, the default is
   <data name="SDKSchemaCommandDefinition" xml:space="preserve">
     <value>Display the command schema as JSON.</value>
   </data>
-</root>
+  <data name="PackCmd_OneNuspecAllowed" xml:space="preserve">
+    <value>Only one .nuspec file can be packed at a time</value>
+  </data>
+</root>

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -2634,4 +2634,10 @@ Proceed?</value>
   <data name="TestCommandUseTestModules" xml:space="preserve">
     <value>Specifying dlls or executables for 'dotnet test' should be via '--test-modules'.</value>
   </data>
+  <data name="PackCmdVersionDescription" xml:space="preserve">
+    <value>The version of the package to create</value>
+  </data>
+  <data name="PackCmdVersion" xml:space="preserve">
+    <value>VERSION</value>
+  </data>
 </root>

src/Cli/dotnet/Commands/Pack/PackCommand.cs

@@ -1,10 +1,19 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.ObjectModel;
 using System.CommandLine;
+using System.CommandLine.Parsing;
+using System.Configuration;
+using Microsoft.DotNet.Cli.Commands.Build;
 using Microsoft.DotNet.Cli.Commands.Restore;
 using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.NuGetPackageDownloader;
 using Microsoft.DotNet.Cli.Utils;
+using NuGet.Commands;
+using NuGet.Common;
+using NuGet.Packaging;
+using NuGet.Packaging.Core;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
@@ -22,8 +31,6 @@ public static PackCommand FromArgs(string[] args, string? msbuildPath = null)
 
     public static PackCommand FromParseResult(ParseResult parseResult, string? msbuildPath = null)
     {
-        parseResult.ShowHelpOrErrorIfAppropriate();
-
         var msbuildArgs = parseResult.OptionValuesToBeForwarded(PackCommandParser.GetCommand()).Concat(parseResult.GetValue(PackCommandParser.SlnOrProjectArgument) ?? []);
 
         ReleasePropertyProjectLocator projectLocator = new(parseResult, MSBuildPropertyNames.PACK_RELEASE,
@@ -46,10 +53,73 @@ public static PackCommand FromParseResult(ParseResult parseResult, string? msbui
             msbuildPath);
     }
 
+    private static LogLevel MappingVerbosityToNugetLogLevel(VerbosityOptions? verbosity)
+    {
+        return verbosity switch
+        {
+            VerbosityOptions.diagnostic or VerbosityOptions.diag => LogLevel.Debug,
+            VerbosityOptions.minimal or VerbosityOptions.m => LogLevel.Minimal,
+            VerbosityOptions.normal or VerbosityOptions.n => LogLevel.Information,
+            VerbosityOptions.detailed or VerbosityOptions.d => LogLevel.Verbose,
+            _ => LogLevel.Minimal
+        };
+    }
+
+    public static int RunPackCommand(ParseResult parseResult)
+    {
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectArgument)?.ToList() ?? new List<string>();
+
+        if (args.Count != 1)
+        {
+            Console.Error.WriteLine(CliStrings.PackCmd_OneNuspecAllowed); 
+            return 1;
+        }
+
+        var nuspecPath = args[0];
+
+        var packArgs = new PackArgs()
+        { 
+            Logger = new NuGetConsoleLogger(),
+            Exclude = new List<string>(),
+            OutputDirectory = parseResult.GetValue(PackCommandParser.OutputOption),
+            LogLevel = MappingVerbosityToNugetLogLevel(parseResult.GetValue(BuildCommandParser.VerbosityOption)),
+            Arguments = [nuspecPath]
+        };
+
+        packArgs.Path = PackCommandRunner.GetInputFile(packArgs);
+        packArgs.BasePath = Path.GetDirectoryName(packArgs.Path);
+        PackCommandRunner.SetupCurrentDirectory(packArgs);
+
+        var globalProperties = parseResult.GetResult("--property") is OptionResult propResult ? propResult.GetValueOrDefault<ReadOnlyDictionary<string, string>?>() : null;
+        if (globalProperties != null)
+            packArgs.Properties.AddRange(globalProperties);
+
+        var version = parseResult.GetValue(PackCommandParser.VersionOption);
+        if (version != null)
+            packArgs.Version = version.ToNormalizedString();
+
+        var configuration = parseResult.GetValue(PackCommandParser.ConfigurationOption) ?? "Debug";
+        packArgs.Properties["configuration"] = configuration;
+
+        var packCommandRunner = new PackCommandRunner(packArgs, null);
+        if (!packCommandRunner.RunPackageBuild())
+            return 1;
+        return 0;
+    }
+
     public static int Run(ParseResult parseResult)
     {
         parseResult.HandleDebugSwitch();
+        parseResult.ShowHelpOrErrorIfAppropriate();
+
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectArgument)?.ToList() ?? new List<string>();
+
+        if (args.Count > 0 && Path.GetExtension(args[0]).Equals(".nuspec", StringComparison.OrdinalIgnoreCase))
+        {
+            return RunPackCommand(parseResult);
+        }
 
+        // Fallback to MSBuild-based packing
         return FromParseResult(parseResult).Execute();
     }
 }

src/Cli/dotnet/Commands/Pack/PackCommandParser.cs

@@ -1,10 +1,16 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.ObjectModel;
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Build;
 using Microsoft.DotNet.Cli.Commands.Restore;
 using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.NuGetPackageDownloader;
+using NuGet.Commands;
+using NuGet.Common;
+using NuGet.Versioning;
+using static Microsoft.DotNet.Cli.Commands.Run.CSharpDirective;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
@@ -61,6 +67,25 @@ internal static class PackCommandParser
     public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
     public static readonly Option<Utils.VerbosityOptions?> VerbosityOption = BuildCommandParser.VerbosityOption;
 
+    public static Option<NuGetVersion> VersionOption =
+        new ForwardedOption<NuGetVersion>("--version")
+        {
+            Description = CliCommandStrings.PackCmdVersionDescription,
+            HelpName = CliCommandStrings.PackCmdVersion,
+            Arity = ArgumentArity.ExactlyOne,
+            CustomParser = r =>
+            {
+                if (r.Tokens.Count == 0)
+                    return null;
+                var value = r.Tokens[0].Value;
+                if (NuGetVersion.TryParse(value, out var version))
+                    return version;
+                r.AddError(string.Format(CliStrings.InvalidVersion, value));
+                return null;
+
+            }
+        }.ForwardAsSingle(o => $"--property:PackageVersion={o}");
+
     private static readonly Command Command = ConstructCommand();
 
     public static Command GetCommand()
@@ -84,6 +109,7 @@ private static Command ConstructCommand()
         command.Options.Add(NoRestoreOption);
         command.Options.Add(VerbosityOption);
         command.Options.Add(CommonOptions.VersionSuffixOption);
+        command.Options.Add(VersionOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
         command.Options.Add(TargetOption);