Implementing dotnet pack with nuspec files

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -2524,4 +2524,16 @@ Proceed?</value>
     <value>Tool package download needs confirmation. Run in interactive mode or use the "--yes" command-line option to confirm.</value>
     <comment>{Locked="--yes"}</comment>
   </data>
-</root>
+  <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>
+  <data name="PackCmdPropertiesDescription" xml:space="preserve">
+    <value>Sets properties for the pack operation</value>
+  </data>
+  <data name="PackCmdProperties" xml:space="preserve">
+    <value>PROPERTY</value>
+  </data>
+</root>

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

@@ -4,7 +4,10 @@
 using System.CommandLine;
 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.Packaging.Core;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
@@ -23,7 +26,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) ?? []);
 
@@ -40,16 +42,61 @@ public static PackCommand FromParseResult(ParseResult parseResult, string? msbui
             CommonOptions.PropertiesOption,
             CommonOptions.RestorePropertiesOption,
             PackCommandParser.TargetOption);
+
         return new PackCommand(
             parsedMSBuildArgs.CloneWithAdditionalProperties(projectLocator.GetCustomDefaultConfigurationValueIfSpecified()),
             noRestore,
             msbuildPath);
     }
 
+    public static int RunPackCommand(ParseResult parseResult)
+    {
+        var args = parseResult.GetValue(PackCommandParser.SlnOrProjectArgument)?.ToList() ?? new List<string>();
+        var nuspecPath = args[0];
+
+        var packArgs = new PackArgs()
+        {
+            Path = nuspecPath,
+            BasePath = Path.GetDirectoryName(nuspecPath),
+            Logger = new NuGetConsoleLogger(),
+            Exclude = new List<string>()
+        };
+
+        var properties = parseResult.GetValue(PackCommandParser.PropertiesOption);
+        if (properties != null)
+        {
+            foreach (var prop in properties)
+            {
+                var split = prop.Split('=', 2);
+                if (split.Length == 2)
+                    packArgs.Properties[split[0]] = split[1];
+            }
+        }
+
+        var version = parseResult.GetValue(PackCommandParser.VersionOption);
+        if (!string.IsNullOrEmpty(version))
+            packArgs.Version = version;
+
+        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

@@ -5,6 +5,10 @@
 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 static Microsoft.DotNet.Cli.Commands.Run.CSharpDirective;
 
 namespace Microsoft.DotNet.Cli.Commands.Pack;
 
@@ -60,6 +64,20 @@ internal static class PackCommandParser
 
     public static readonly Option<string[]> TargetOption = CommonOptions.RequiredMSBuildTargetOption("Pack", [("_IsPacking", "true")]);
 
+    public static readonly Option<string> VersionOption = new ForwardedOption<string>("--version")
+    {
+        Description = CliCommandStrings.PackCmdVersionDescription,
+        HelpName = CliCommandStrings.PackCmdVersion,
+        Hidden = false
+    }.ForwardAsSingle(o => $"-Version={o}");
+
+    public static readonly Option<string[]> PropertiesOption = new ForwardedOption<string[]>("--property")
+    {
+        Description = CliCommandStrings.PackCmdPropertiesDescription,
+        HelpName = CliCommandStrings.PackCmdProperties,
+        Hidden = false
+    };
+
     private static readonly Command Command = ConstructCommand();
 
     public static Command GetCommand()
@@ -82,10 +100,11 @@ private static Command ConstructCommand()
         command.Options.Add(CommonOptions.InteractiveMsBuildForwardOption);
         command.Options.Add(NoRestoreOption);
         command.Options.Add(BuildCommandParser.VerbosityOption);
+        command.Options.Add(VersionOption);
         command.Options.Add(CommonOptions.VersionSuffixOption);
         command.Options.Add(ConfigurationOption);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
-        command.Options.Add(TargetOption);
+        command.Options.Add(TargetOption); 
 
         // Don't include runtime option because we want to include it specifically and allow the short version ("-r") to be used
         RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: true);