Add dotnet nuget why command

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/WhyCommand/DependencyNode.cs

@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#nullable enable
+
+using System.Collections.Generic;
+using NuGet.Shared;
+
+namespace NuGet.CommandLine.XPlat
+{
+    /// <summary>
+    /// Represents a node in the package dependency graph.
+    /// </summary>
+    internal class DependencyNode
+    {
+        public string Id { get; set; }
+        public string Version { get; set; }
+        public HashSet<DependencyNode> Children { get; set; }
+
+        public DependencyNode(string id, string version)
+        {
+            Id = id;
+            Version = version;
+            Children = new HashSet<DependencyNode>();
+        }
+
+        public override int GetHashCode()
+        {
+            var hashCodeCombiner = new HashCodeCombiner();
+            hashCodeCombiner.AddObject(Id);
+            hashCodeCombiner.AddObject(Version);
+            hashCodeCombiner.AddUnorderedSequence(Children);
+            return hashCodeCombiner.CombinedHash;
+        }
+    }
+}

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/WhyCommand/WhyCommand.cs

@@ -0,0 +1,70 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.CommandLine.Help;
+
+namespace NuGet.CommandLine.XPlat
+{
+    internal static class WhyCommand
+    {
+        private static CliArgument<string> Path = new CliArgument<string>("PROJECT|SOLUTION")
+        {
+            Description = Strings.WhyCommand_PathArgument_Description,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        private static CliArgument<string> Package = new CliArgument<string>("PACKAGE")
+        {
+            Description = Strings.WhyCommand_PackageArgument_Description,
+            Arity = ArgumentArity.ExactlyOne
+        };
+
+        private static CliOption<List<string>> Frameworks = new CliOption<List<string>>("--framework", "-f")
+        {
+            Description = Strings.WhyCommand_FrameworksOption_Description,
+            Arity = ArgumentArity.OneOrMore
+        };
+
+        private static HelpOption Help = new HelpOption()
+        {
+            Arity = ArgumentArity.Zero
+        };
+
+        internal static void Register(CliCommand rootCommand, Func<ILoggerWithColor> getLogger)
+        {
+            var whyCommand = new CliCommand("why", Strings.WhyCommand_Description);
+
+            whyCommand.Arguments.Add(Path);
+            whyCommand.Arguments.Add(Package);
+            whyCommand.Options.Add(Frameworks);
+            whyCommand.Options.Add(Help);
+
+            whyCommand.SetAction((parseResult) =>
+            {
+                ILoggerWithColor logger = getLogger();
+
+                try
+                {
+                    var whyCommandArgs = new WhyCommandArgs(
+                        parseResult.GetValue(Path),
+                        parseResult.GetValue(Package),
+                        parseResult.GetValue(Frameworks),
+                        logger);
+
+                    int exitCode = WhyCommandRunner.ExecuteCommand(whyCommandArgs);
+                    return exitCode;
+                }
+                catch (ArgumentException ex)
+                {
+                    logger.LogError(ex.Message);
+                    return ExitCodes.InvalidArguments;
+                }
+            });
+
+            rootCommand.Subcommands.Add(whyCommand);
+        }
+    }
+}

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/WhyCommand/WhyCommandArgs.cs

@@ -0,0 +1,37 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+
+namespace NuGet.CommandLine.XPlat
+{
+    internal class WhyCommandArgs
+    {
+        public string Path { get; }
+        public string Package { get; }
+        public List<string> Frameworks { get; }
+        public ILoggerWithColor Logger { get; }
+
+        /// <summary>
+        /// A constructor for the arguments of the 'why' command.
+        /// </summary>
+        /// <param name="path">The path to the solution or project file.</param>
+        /// <param name="package">The package for which we show the dependency graphs.</param>
+        /// <param name="frameworks">The target framework(s) for which we show the dependency graphs.</param>
+        /// <param name="logger"></param>
+        public WhyCommandArgs(
+            string path,
+            string package,
+            List<string> frameworks,
+            ILoggerWithColor logger)
+        {
+            Path = path ?? throw new ArgumentNullException(nameof(path));
+            Package = package ?? throw new ArgumentNullException(nameof(package));
+            Frameworks = frameworks ?? throw new ArgumentNullException(nameof(frameworks));
+            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+    }
+}

src/NuGet.Core/NuGet.CommandLine.XPlat/Commands/WhyCommand/WhyCommandRunner.cs

@@ -0,0 +1,168 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using Microsoft.Build.Evaluation;
+using NuGet.CommandLine.XPlat.WhyCommandUtility;
+using NuGet.ProjectModel;
+
+namespace NuGet.CommandLine.XPlat
+{
+    internal static class WhyCommandRunner
+    {
+        private const string ProjectName = "MSBuildProjectName";
+        private const string ProjectAssetsFile = "ProjectAssetsFile";
+
+        /// <summary>
+        /// Executes the 'why' command.
+        /// </summary>
+        /// <param name="whyCommandArgs">CLI arguments for the 'why' command.</param>
+        public static int ExecuteCommand(WhyCommandArgs whyCommandArgs)
+        {
+            try
+            {
+                ValidatePathArgument(whyCommandArgs.Path);
+                ValidatePackageArgument(whyCommandArgs.Package);
+            }
+            catch (ArgumentException ex)
+            {
+                whyCommandArgs.Logger.LogError(ex.Message);
+                return ExitCodes.InvalidArguments;
+            }
+
+            string targetPackage = whyCommandArgs.Package;
+
+            IEnumerable<string> projectPaths = Path.GetExtension(whyCommandArgs.Path).Equals(".sln")
+                                                    ? MSBuildAPIUtility.GetProjectsFromSolution(whyCommandArgs.Path).Where(f => File.Exists(f))
+                                                    : [whyCommandArgs.Path];
+
+            foreach (var projectPath in projectPaths)
+            {
+                Project project = MSBuildAPIUtility.GetProject(projectPath);
+                LockFile? assetsFile = GetProjectAssetsFile(project, whyCommandArgs.Logger);
+
+                if (assetsFile != null)
+                {
+                    Dictionary<string, List<DependencyNode>?>? dependencyGraphPerFramework = DependencyGraphFinder.GetAllDependencyGraphs(
+                        assetsFile,
+                        whyCommandArgs.Package,
+                        whyCommandArgs.Frameworks);
+
+                    if (dependencyGraphPerFramework != null)
+                    {
+                        whyCommandArgs.Logger.LogMinimal(
+                            string.Format(
+                                Strings.WhyCommand_Message_DependencyGraphsFoundInProject,
+                                project.GetPropertyValue(ProjectName),
+                                targetPackage));
+
+                        DependencyGraphPrinter.PrintAllDependencyGraphs(dependencyGraphPerFramework, targetPackage, whyCommandArgs.Logger);
+                    }
+                    else
+                    {
+                        whyCommandArgs.Logger.LogMinimal(
+                            string.Format(
+                                Strings.WhyCommand_Message_NoDependencyGraphsFoundInProject,
+                                project.GetPropertyValue(ProjectName),
+                                targetPackage));
+                    }
+                }
+
+                ProjectCollection.GlobalProjectCollection.UnloadProject(project);
+            }
+
+            return ExitCodes.Success;
+        }
+
+        private static void ValidatePathArgument(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentException(
+                    string.Format(CultureInfo.CurrentCulture,
+                    Strings.WhyCommand_Error_ArgumentCannotBeEmpty,
+                    "PROJECT|SOLUTION"));
+            }
+
+            if (!File.Exists(path)
+                || (!path.EndsWith("proj", StringComparison.OrdinalIgnoreCase)
+                    && !path.EndsWith(".sln", StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new ArgumentException(
+                    string.Format(CultureInfo.CurrentCulture,
+                    Strings.WhyCommand_Error_PathIsMissingOrInvalid,
+                    path));
+            }
+        }
+
+        private static void ValidatePackageArgument(string package)
+        {
+            if (string.IsNullOrEmpty(package))
+            {
+                throw new ArgumentException(
+                    string.Format(CultureInfo.CurrentCulture,
+                    Strings.WhyCommand_Error_ArgumentCannotBeEmpty,
+                    "PACKAGE"));
+            }
+        }
+
+        /// <summary>
+        /// Validates and returns the assets file for the given project.
+        /// </summary>
+        /// <param name="project">Evaluated MSBuild project</param>
+        /// <param name="logger">Logger for the 'why' command</param>
+        /// <returns>Assets file for the given project. Returns null if there was any issue finding or parsing the assets file.</returns>
+        private static LockFile? GetProjectAssetsFile(Project project, ILoggerWithColor logger)
+        {
+            if (!MSBuildAPIUtility.IsPackageReferenceProject(project))
+            {
+                logger.LogError(
+                    string.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.Error_NotPRProject,
+                        project.FullPath));
+
+                return null;
+            }
+
+            string assetsPath = project.GetPropertyValue(ProjectAssetsFile);
+
+            if (!File.Exists(assetsPath))
+            {
+                logger.LogError(
+                    string.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.Error_AssetsFileNotFound,
+                        project.FullPath));
+
+                return null;
+            }
+
+            var lockFileFormat = new LockFileFormat();
+            LockFile assetsFile = lockFileFormat.Read(assetsPath);
+
+            // assets file validation
+            if (assetsFile.PackageSpec == null
+                || assetsFile.Targets == null
+                || assetsFile.Targets.Count == 0)
+            {
+                logger.LogError(
+                    string.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.WhyCommand_Error_InvalidAssetsFile,
+                        assetsFile.Path,
+                        project.FullPath));
+
+                return null;
+            }
+
+            return assetsFile;
+        }
+    }
+}