Look for local tools first with dotnet tool exec

Author: dsplaisted

src/Cli/dotnet/Commands/Tool/Execute/ToolExecuteCommand.cs

@@ -5,15 +5,24 @@
 using Microsoft.DotNet.Cli.CommandFactory;
 using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
 using Microsoft.DotNet.Cli.Commands.Tool.Install;
+using Microsoft.DotNet.Cli.Commands.Tool.Restore;
+using Microsoft.DotNet.Cli.Commands.Tool.Run;
+using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.NuGetPackageDownloader;
+using Microsoft.DotNet.Cli.ToolManifest;
 using Microsoft.DotNet.Cli.ToolPackage;
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Cli.Utils.Extensions;
+
+using Microsoft.Extensions.EnvironmentAbstractions;
 using NuGet.Common;
 using NuGet.Packaging.Core;
 using NuGet.Versioning;
 
+
 namespace Microsoft.DotNet.Cli.Commands.Tool.Execute
 {
-    internal class ToolExecuteCommand(ParseResult result) : CommandBase(result)
+    internal class ToolExecuteCommand(ParseResult result, ToolManifestFinder? toolManifestFinder = null, string? currentWorkingDirectory = null) : CommandBase(result)
     {
         private readonly PackageIdentity _packageToolIdentityArgument = result.GetRequiredValue(ToolExecuteCommandParser.PackageIdentityArgument);
         private readonly IEnumerable<string> _forwardArguments = result.GetValue(ToolExecuteCommandParser.CommandArgument) ?? Enumerable.Empty<string>();
@@ -25,10 +34,60 @@ internal class ToolExecuteCommand(ParseResult result) : CommandBase(result)
         private readonly bool _interactive = result.GetValue(ToolExecuteCommandParser.InteractiveOption);
         private readonly VerbosityOptions _verbosity = result.GetValue(ToolExecuteCommandParser.VerbosityOption);
         private readonly bool _yes = result.GetValue(ToolExecuteCommandParser.YesOption);
+
+        //  TODO: Does result.OptionValuesToBeForwarded work here?
+        private readonly IToolPackageDownloader _toolPackageDownloader = ToolPackageFactory.CreateToolPackageStoresAndDownloader(
+                additionalRestoreArguments: result.OptionValuesToBeForwarded(ToolExecuteCommandParser.GetCommand())).Item3;
+
+        //  TODO: Make sure to add these options to the command
+        private readonly RestoreActionConfig _restoreActionConfig = new RestoreActionConfig(DisableParallel: result.GetValue(ToolCommandRestorePassThroughOptions.DisableParallelOption),
+            NoCache: result.GetValue(ToolCommandRestorePassThroughOptions.NoCacheOption) || result.GetValue(ToolCommandRestorePassThroughOptions.NoHttpCacheOption),
+            IgnoreFailedSources: result.GetValue(ToolCommandRestorePassThroughOptions.IgnoreFailedSourcesOption),
+            Interactive: result.GetValue(ToolCommandRestorePassThroughOptions.InteractiveRestoreOption));
+
+        //  TODO: Use prerelease
         private readonly bool _prerelease = result.GetValue(ToolExecuteCommandParser.PrereleaseOption);
 
+        private readonly ToolManifestFinder _toolManifestFinder = toolManifestFinder ?? new ToolManifestFinder(new DirectoryPath(currentWorkingDirectory ?? Directory.GetCurrentDirectory()));
+
         public override int Execute()
         {
+            VersionRange versionRange = _parseResult.GetVersionRange();
+            PackageId packageId = new PackageId(_packageToolIdentityArgument.Id);
+
+            //  Look in local tools manifest first, but only if version is not specified
+            if (versionRange == null)
+            {
+                var localToolsResolverCache = new LocalToolsResolverCache();
+
+                if (_toolManifestFinder.TryFindPackageId(packageId, out var toolManifestPackage))
+                {
+                    var toolPackageRestorer = new ToolPackageRestorer(
+                        _toolPackageDownloader,
+                        _sources,
+                        overrideSources: [],
+                        _verbosity,
+                        _restoreActionConfig,
+                        localToolsResolverCache,
+                        new FileSystemWrapper());
+
+                    var restoreResult = toolPackageRestorer.InstallPackage(toolManifestPackage, _configFile == null ? null : new FilePath(_configFile));
+
+                    if (!restoreResult.IsSuccess)
+                    {
+                        Reporter.Error.WriteLine(restoreResult.Message.Red());
+                        return 1;
+                    }
+
+                    var localToolsCommandResolver = new LocalToolsCommandResolver(
+                        _toolManifestFinder,
+                        localToolsResolverCache);
+
+                    return ToolRunCommand.ExecuteCommand(localToolsCommandResolver, toolManifestPackage.CommandNames.Single().Value, _forwardArguments, _allowRollForward);
+                }
+            }
+
+
             if (!UserAgreedToRunFromSource())
             {
                 throw new GracefulException(CliCommandStrings.ToolRunFromSourceUserConfirmationFailed, isUserError: true);
@@ -39,16 +98,10 @@ public override int Execute()
                 _forwardArguments.Append("--allow-roll-forward");
             }
 
-            PackageId packageId = new PackageId(_packageToolIdentityArgument.Id);
-
-            VersionRange versionRange = _parseResult.GetVersionRange();
 
             string tempDirectory = NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp);
 
-            ToolPackageStoreAndQuery toolPackageStoreAndQuery = new(new(tempDirectory));
-            ToolPackageDownloader toolPackageDownloader = new(toolPackageStoreAndQuery);
-
-            IToolPackage toolPackage = toolPackageDownloader.InstallPackage(
+            IToolPackage toolPackage = _toolPackageDownloader.InstallPackage(
                 new PackageLocation(
                     nugetConfig: _configFile != null ? new(_configFile) : null,
                     sourceFeedOverrides: _sources,

src/Cli/dotnet/Commands/Tool/Run/ToolRunCommand.cs

@@ -28,17 +28,21 @@ internal class ToolRunCommand(
 
     public override int Execute()
     {
-        CommandSpec commandSpec = _localToolsCommandResolver.ResolveStrict(new CommandResolverArguments()
+        return ExecuteCommand(_localToolsCommandResolver, _toolCommandName, _forwardArgument, _allowRollForward);
+    }
+    public static int ExecuteCommand(LocalToolsCommandResolver commandResolver, string toolCommandName, IEnumerable<string> argumentsToForward, bool allowRollForward)
+    {
+        CommandSpec commandSpec = commandResolver.ResolveStrict(new CommandResolverArguments()
         {
             // since LocalToolsCommandResolver is a resolver, and all resolver input have dotnet-
-            CommandName = $"dotnet-{_toolCommandName}",
-            CommandArguments = _forwardArgument,
+            CommandName = $"dotnet-{toolCommandName}",
+            CommandArguments = argumentsToForward,
 
-        }, _allowRollForward);
+        }, allowRollForward);
 
         if (commandSpec == null)
         {
-            throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, _toolCommandName)], isUserError: false);
+            throw new GracefulException([string.Format(CliCommandStrings.CannotFindCommandName, toolCommandName)], isUserError: false);
         }
 
         var result = CommandFactoryUsingResolver.Create(commandSpec).Execute();

src/Cli/dotnet/ToolManifest/ToolManifestFinder.cs

@@ -132,6 +132,34 @@ public bool TryFind(ToolCommandName toolCommandName, out ToolManifestPackage too
         return false;
     }
 
+    public bool TryFindPackageId(PackageId packageId, out ToolManifestPackage toolManifestPackage)
+    {
+        toolManifestPackage = default;
+        foreach ((FilePath possibleManifest, DirectoryPath correspondingDirectory) in
+            EnumerateDefaultAllPossibleManifests())
+        {
+            if (!_fileSystem.File.Exists(possibleManifest.Value))
+            {
+                continue;
+            }
+            (List<ToolManifestPackage> manifestPackages, bool isRoot) =
+                _toolManifestEditor.Read(possibleManifest, correspondingDirectory);
+            foreach (var package in manifestPackages)
+            {
+                if (package.PackageId.Equals(packageId))
+                {
+                    toolManifestPackage = package;
+                    return true;
+                }
+            }
+            if (isRoot)
+            {
+                return false;
+            }
+        }
+        return false;
+    }
+
     private IEnumerable<(FilePath manifestfile, DirectoryPath manifestFileFirstEffectDirectory)>
         EnumerateDefaultAllPossibleManifests()
     {