Add warnings for newer tool versions during dotnet tool restore

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -1733,6 +1733,9 @@ The default is to publish a framework-dependent application.</value>
   <data name="RestoreSuccessful" xml:space="preserve">
     <value>Tool '{0}' (version '{1}') was restored. Available commands: {2}</value>
   </data>
+  <data name="RestoreNewVersionAvailable" xml:space="preserve">
+    <value>A newer version of tool '{0}' is available (version '{1}'). Consider updating your manifest file.</value>
+  </data>
   <data name="RollbackDefinitionContainsExtraneousManifestIds" xml:space="preserve">
     <value>Invalid rollback definition. The manifest IDs in rollback definition {0} do not match installed manifest IDs {1}.</value>
   </data>

src/Cli/dotnet/Commands/Tool/Restore/ToolPackageRestorer.cs

@@ -83,6 +83,9 @@ public ToolRestoreResult InstallPackage(
                         toolPackage.Command.Name));
             }
 
+            // Check for newer versions and prepare warning message
+            string warning = CheckForNewerVersion(package, configFile);
+
             return ToolRestoreResult.Success(
                 saveToCache:
                     (new RestoredCommandIdentifier(
@@ -96,7 +99,8 @@ public ToolRestoreResult InstallPackage(
                     CliCommandStrings.RestoreSuccessful,
                     package.PackageId,
                     package.Version.ToNormalizedString(),
-                    string.Join(" ", package.CommandNames)));
+                    string.Join(" ", package.CommandNames)),
+                warning: warning);
         }
         catch (ToolPackageException e)
         {
@@ -129,6 +133,44 @@ public bool PackageHasBeenRestored(
                && _fileSystem.File.Exists(toolCommand.Executable.Value);
     }
 
+    private string CheckForNewerVersion(ToolManifestPackage package, FilePath? configFile)
+    {
+        try
+        {
+            // Use wildcard version range to get the latest version
+            var latestVersionRange = VersionRange.Parse("*");
+
+            var (latestVersion, _) = _toolPackageDownloader.GetNuGetVersion(
+                new PackageLocation(
+                    nugetConfig: configFile,
+                    additionalFeeds: _additionalSources,
+                    sourceFeedOverrides: _overrideSources,
+                    rootConfigDirectory: package.FirstEffectDirectory),
+                package.PackageId,
+                _verbosity,
+                latestVersionRange,
+                _restoreActionConfig);
+
+            // Compare versions - only warn if there's a newer stable version or if the manifest uses prerelease
+            if (latestVersion != null && latestVersion > package.Version)
+            {
+                // If the current version is prerelease, show warning for any newer version
+                // If the current version is stable, only show warning for newer stable versions
+                if (package.Version.IsPrerelease || !latestVersion.IsPrerelease)
+                {
+                    return string.Format(CliCommandStrings.RestoreNewVersionAvailable, package.PackageId, latestVersion.ToNormalizedString());
+                }
+            }
+        }
+        catch
+        {
+            // If we can't check for newer versions, don't show a warning
+            // This could happen due to network issues, package source problems, etc.
+        }
+
+        return string.Empty;
+    }
+
     private static string JoinBySpaceWithQuote(IEnumerable<object> objects)
     {
         return string.Join(" ", objects.Select(o => $"\"{o.ToString()}\""));

src/Cli/dotnet/Commands/Tool/Restore/ToolRestoreCommand.cs

@@ -142,7 +142,14 @@ private int PrintConclusionAndReturn(ToolRestoreResult[] toolRestoreResults)
             {
                 _reporter.WriteLine();
                 _reporter.WriteLine(string.Join(Environment.NewLine, successMessage));
-
+
+                // Display warnings for successful restorations even in partial failure case
+                var warnings = toolRestoreResults.Where(r => r.IsSuccess && !string.IsNullOrEmpty(r.Warning)).Select(r => r.Warning);
+                if (warnings.Any())
+                {
+                    _reporter.WriteLine();
+                    _reporter.WriteLine(string.Join(Environment.NewLine, warnings).Yellow());
+                }
             }
 
             _errorReporter.WriteLine(Environment.NewLine +
@@ -156,6 +163,15 @@ private int PrintConclusionAndReturn(ToolRestoreResult[] toolRestoreResults)
         {
             _reporter.WriteLine(string.Join(Environment.NewLine,
                 toolRestoreResults.Where(r => r.IsSuccess).Select(r => r.Message)));
+
+            // Display warnings for newer versions available
+            var warnings = toolRestoreResults.Where(r => r.IsSuccess && !string.IsNullOrEmpty(r.Warning)).Select(r => r.Warning);
+            if (warnings.Any())
+            {
+                _reporter.WriteLine();
+                _reporter.WriteLine(string.Join(Environment.NewLine, warnings).Yellow());
+            }
+
             _reporter.WriteLine();
             _reporter.WriteLine(CliCommandStrings.LocalToolsRestoreWasSuccessful.Green());
 
@@ -205,10 +221,11 @@ public struct ToolRestoreResult
         public (RestoredCommandIdentifier restoredCommandIdentifier, ToolCommand toolCommand)? SaveToCache { get; }
         public bool IsSuccess { get; }
         public string Message { get; }
+        public string Warning { get; }
 
         private ToolRestoreResult(
             (RestoredCommandIdentifier, ToolCommand)? saveToCache,
-            bool isSuccess, string message)
+            bool isSuccess, string message, string warning = null)
         {
             if (string.IsNullOrWhiteSpace(message))
             {
@@ -218,18 +235,20 @@ private ToolRestoreResult(
             SaveToCache = saveToCache;
             IsSuccess = isSuccess;
             Message = message;
+            Warning = warning;
         }
 
         public static ToolRestoreResult Success(
             (RestoredCommandIdentifier, ToolCommand)? saveToCache,
-            string message)
+            string message,
+            string warning = null)
         {
-            return new ToolRestoreResult(saveToCache, true, message);
+            return new ToolRestoreResult(saveToCache, true, message, warning);
         }
 
         public static ToolRestoreResult Failure(string message)
         {
-            return new ToolRestoreResult(null, false, message);
+            return new ToolRestoreResult(null, false, message, null);
         }
 
         public static ToolRestoreResult Failure(
@@ -238,7 +257,7 @@ public static ToolRestoreResult Failure(
         {
             return new ToolRestoreResult(null, false,
                 string.Format(CliCommandStrings.PackageFailedToRestore,
-                    packageId.ToString(), toolPackageException.ToString()));
+                    packageId.ToString(), toolPackageException.ToString()), null);
         }
     }
 }

test/dotnet.Tests/CommandTests/Tool/Restore/ToolRestoreCommandTests.cs

@@ -532,6 +532,61 @@ public void WhenRunWithoutManifestFileItShouldPrintSpecificRestoreErrorMessage()
                 l.Contains(AnsiExtensions.Yellow(CliCommandStrings.NoToolsWereRestored)));
         }
 
+        [Fact]
+        public void WhenNewerVersionIsAvailableItShowsWarning()
+        {
+            var newerPackageVersion = NuGetVersion.Parse("2.1.4");
+            var manifestPackage = new ToolManifestPackage(
+                _packageIdA,
+                _packageVersionA,
+                new[] { _toolCommandNameA },
+                new DirectoryPath(_temporaryDirectory),
+                rollForward: false);
+
+            // Create a mock feed with both the current version and a newer version
+            var feeds = new List<MockFeed>
+            {
+                new MockFeed
+                {
+                    Type = MockFeedType.FeedFromGlobalNugetConfig,
+                    Packages = new List<MockFeedPackage>
+                    {
+                        new MockFeedPackage
+                        {
+                            PackageId = _packageIdA.ToString(),
+                            Version = _packageVersionA.ToNormalizedString(),
+                            ToolCommandName = _toolCommandNameA.Value,
+                        },
+                        new MockFeedPackage
+                        {
+                            PackageId = _packageIdA.ToString(),
+                            Version = newerPackageVersion.ToNormalizedString(),
+                            ToolCommandName = _toolCommandNameA.Value,
+                        }
+                    }
+                }
+            };
+
+            var toolPackageDownloaderMockWithFeeds = new ToolPackageDownloaderMock(
+                _toolPackageStore, _fileSystem, feeds: feeds);
+
+            IToolManifestFinder fakeManifestFinder =
+                new MockManifestFinder(new[] { manifestPackage });
+
+            ToolRestoreCommand toolRestoreCommand = new(_parseResult,
+                toolPackageDownloaderMockWithFeeds,
+                fakeManifestFinder,
+                _localToolsResolverCache,
+                _fileSystem,
+                _reporter
+            );
+
+            toolRestoreCommand.Execute().Should().Be(0);
+
+            _reporter.Lines.Should().Contain(l =>
+                l.Contains(string.Format(CliCommandStrings.RestoreNewVersionAvailable, _packageIdA, newerPackageVersion.ToNormalizedString())));
+        }
+
         private class MockManifestFinder : IToolManifestFinder
         {
             private readonly IReadOnlyCollection<ToolManifestPackage> _toReturn;