Fix PR channel version selection in Aspire CLI

src/Aspire.Cli/Commands/AddCommand.cs

@@ -28,6 +28,7 @@ internal sealed class AddCommand : BaseCommand
     private readonly IDotNetSdkInstaller _sdkInstaller;
     private readonly ICliHostEnvironment _hostEnvironment;
     private readonly IAppHostProjectFactory _projectFactory;
+    private readonly FallbackProjectParser _fallbackProjectParser;
 
     private static readonly Argument<string> s_integrationArgument = new("integration")
     {
@@ -44,7 +45,7 @@ internal sealed class AddCommand : BaseCommand
         Description = AddCommandStrings.SourceArgumentDescription
     };
 
-    public AddCommand(IPackagingService packagingService, IInteractionService interactionService, IProjectLocator projectLocator, IAddCommandPrompter prompter, AspireCliTelemetry telemetry, IDotNetSdkInstaller sdkInstaller, IFeatures features, ICliUpdateNotifier updateNotifier, CliExecutionContext executionContext, ICliHostEnvironment hostEnvironment, IAppHostProjectFactory projectFactory)
+    public AddCommand(IPackagingService packagingService, IInteractionService interactionService, IProjectLocator projectLocator, IAddCommandPrompter prompter, AspireCliTelemetry telemetry, IDotNetSdkInstaller sdkInstaller, IFeatures features, ICliUpdateNotifier updateNotifier, CliExecutionContext executionContext, ICliHostEnvironment hostEnvironment, IAppHostProjectFactory projectFactory, FallbackProjectParser fallbackProjectParser)
         : base("add", AddCommandStrings.Description, features, updateNotifier, executionContext, interactionService, telemetry)
     {
         _packagingService = packagingService;
@@ -53,6 +54,7 @@ public AddCommand(IPackagingService packagingService, IInteractionService intera
         _sdkInstaller = sdkInstaller;
         _hostEnvironment = hostEnvironment;
         _projectFactory = projectFactory;
+        _fallbackProjectParser = fallbackProjectParser;
 
         Arguments.Add(s_integrationArgument);
         Options.Add(s_appHostOption);
@@ -208,6 +210,19 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             };
 
             // Add the package using the appropriate project handler
+            if (string.IsNullOrEmpty(source) && VersionHelper.IsPrChannel(selectedNuGetPackage.Channel.Name))
+            {
+                var nugetConfigPrompter = new NuGetConfigPrompter(InteractionService);
+                var scopedPackageIds = GetScopedPrHivePackageIds(
+                    effectiveAppHostProjectFile,
+                    selectedNuGetPackage.Package.Id,
+                    selectedNuGetPackage.Package.Version);
+                await nugetConfigPrompter.CreateOrUpdateWithoutPromptAsync(
+                    effectiveAppHostProjectFile.Directory!,
+                    selectedNuGetPackage.Channel.CreateScopedChannelForPackages(scopedPackageIds),
+                    cancellationToken);
+            }
+
             context = new AddPackageContext
             {
                 AppHostFile = effectiveAppHostProjectFile,
@@ -294,7 +309,7 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             _ => throw new InvalidOperationException(AddCommandStrings.UnexpectedNumberOfPackagesFound)
         };
 
-        var packageVersions = possiblePackages.Where(p => p.Package.Id == selectedPackage.Package.Id);
+        var packageVersions = possiblePackages.Where(p => p.Package.Id == selectedPackage.Package.Id).ToArray();
 
         // If any of the package versions are an exact match for the preferred version
         // then we can skip the version prompt and just use that version.
@@ -304,6 +319,22 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             return preferredVersionPackage;
         }
 
+        // When PR hives are present, prefer the package that exactly matches the installed
+        // CLI/SDK version so template- and add-generated projects stay on the same build.
+        var prChannelPackageVersions = packageVersions
+            .Where(p => VersionHelper.IsPrChannel(p.Channel.Name))
+            .ToArray();
+
+        if (VersionHelper.TryGetCurrentCliVersionMatch(
+            prChannelPackageVersions,
+            p => p.Package.Version,
+            out var cliVersionPackage,
+            channelName: null,
+            hasPrHives: ExecutionContext.GetPrHiveCount() > 0))
+        {
+            return cliVersionPackage;
+        }
+
         // In non-interactive mode, prefer the implicit/default channel first to keep
         // package selection aligned with the project's configured feeds. Then select
         // the latest version within the chosen channel.
@@ -339,6 +370,35 @@ internal static (string FriendlyName, NuGetPackage Package, PackageChannel Chann
 
         return (friendlyName, packageWithChannel.Package, packageWithChannel.Channel);
     }
+
+    private IReadOnlyCollection<string> GetScopedPrHivePackageIds(FileInfo appHostProjectFile, string selectedPackageId, string selectedPackageVersion)
+    {
+        var packageIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            selectedPackageId
+        };
+
+        if (!appHostProjectFile.Exists)
+        {
+            return packageIds;
+        }
+
+        using var projectDocument = _fallbackProjectParser.ParseProject(appHostProjectFile);
+        if (!projectDocument.RootElement.TryGetProperty("Properties", out var properties) ||
+            !properties.TryGetProperty("AspireHostingSDKVersion", out var sdkVersionElement))
+        {
+            return packageIds;
+        }
+
+        var sdkVersion = sdkVersionElement.GetString();
+        if (!string.Equals(sdkVersion, selectedPackageVersion, StringComparison.OrdinalIgnoreCase))
+        {
+            return packageIds;
+        }
+
+        packageIds.Add("Aspire.AppHost.Sdk");
+        return packageIds;
+    }
 }
 
 internal interface IAddCommandPrompter

src/Aspire.Cli/Commands/InitCommand.cs

@@ -784,6 +784,7 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             throw new InvalidOperationException("No template versions found");
         }
 
+        var hasPrHives = _executionContext.GetPrHiveCount() > 0;
         var orderedPackagesFromChannels = packagesFromChannels.OrderByDescending(p => SemVersion.Parse(p.Package.Version), SemVersion.PrecedenceComparer);
 
         // Check for explicit version specified via command line
@@ -796,7 +797,17 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             }
         }
 
-        // If channel was specified via --channel option or global setting (but no --version), 
+        if (VersionHelper.TryGetCurrentCliVersionMatch(
+            orderedPackagesFromChannels,
+            p => p.Package.Version,
+            out var cliVersionPackageFromChannel,
+            channelName: channelName,
+            hasPrHives: hasPrHives))
+        {
+            return cliVersionPackageFromChannel;
+        }
+
+        // If channel was specified via --channel option or global setting (but no --version),
         // automatically select the highest version from that channel without prompting
         if (hasChannelSetting)
         {

src/Aspire.Cli/Commands/NewCommand.cs

@@ -318,9 +318,21 @@ private async Task<ResolveTemplateVersionResult> ResolveCliTemplateVersionAsync(
                     return new ResolveTemplateVersionResult { ErrorMessage = errorMessage };
                 }
 
-                var packages = await selectedChannel.GetTemplatePackagesAsync(ExecutionContext.WorkingDirectory, cancellationToken);
-                var package = packages
+                var packages = (await selectedChannel.GetTemplatePackagesAsync(ExecutionContext.WorkingDirectory, cancellationToken))
                     .Where(p => Semver.SemVersion.TryParse(p.Version, Semver.SemVersionStyles.Strict, out _))
+                    .ToArray();
+                var hasPrHives = ExecutionContext.GetPrHiveCount() > 0;
+
+                NuGetPackage? package = VersionHelper.TryGetCurrentCliVersionMatch(
+                    packages,
+                    p => p.Version,
+                    out var cliVersionPackage,
+                    channelName: selectedChannel.Name,
+                    hasPrHives: hasPrHives)
+                    ? cliVersionPackage
+                    : null;
+
+                package ??= packages
                     .OrderByDescending(p => Semver.SemVersion.Parse(p.Version, Semver.SemVersionStyles.Strict), Semver.SemVersion.PrecedenceComparer)
                     .FirstOrDefault();
 

src/Aspire.Cli/Packaging/PackageChannel.cs

@@ -1,8 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.IO.Compression;
+using System.Xml.Linq;
 using Aspire.Cli.NuGet;
 using Aspire.Cli.Resources;
+using Aspire.Cli.Utils;
 using Semver;
 using NuGetPackage = Aspire.Shared.NuGetPackageCli;
 
@@ -193,6 +196,172 @@ public async Task<IEnumerable<NuGetPackage>> GetPackagesAsync(string packageId,
         return filteredPackages;
     }
 
+    public PackageChannel CreateScopedChannelForPackage(string packageId)
+    {
+        return CreateScopedChannelForPackages([packageId]);
+    }
+
+    public PackageChannel CreateScopedChannelForPackages(IEnumerable<string> packageIds)
+    {
+        ArgumentNullException.ThrowIfNull(packageIds);
+
+        var requestedPackageIds = packageIds
+            .Where(packageId => !string.IsNullOrWhiteSpace(packageId))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        if (requestedPackageIds.Length == 0)
+        {
+            throw new ArgumentException("At least one package ID must be provided.", nameof(packageIds));
+        }
+
+        var mappings = Mappings;
+        if (!VersionHelper.IsPrChannel(Name) || Type is not PackageChannelType.Explicit || mappings is not { Length: > 0 })
+        {
+            return this;
+        }
+
+        var scopedMappings = mappings
+            .SelectMany(mapping => CreateScopedMappings(mapping, requestedPackageIds))
+            .ToArray();
+
+        return new PackageChannel(Name, Quality, scopedMappings, nuGetPackageCache, ConfigureGlobalPackagesFolder, CliDownloadBaseUrl, PinnedVersion);
+    }
+
+    private static IEnumerable<PackageMapping> CreateScopedMappings(PackageMapping mapping, IReadOnlyCollection<string> packageIds)
+    {
+        if (!IsScopedAspireMapping(mapping))
+        {
+            yield return mapping;
+            yield break;
+        }
+
+        var scopedPackageIds = GetScopedPackageIds(mapping.Source, packageIds);
+
+        foreach (var scopedPackageId in scopedPackageIds)
+        {
+            yield return new PackageMapping(scopedPackageId, mapping.Source);
+        }
+    }
+
+    private static HashSet<string> GetScopedPackageIds(string source, IEnumerable<string> packageIds)
+    {
+        var resolvedPackageIds = new HashSet<string>(packageIds, StringComparer.OrdinalIgnoreCase);
+
+        if (!Directory.Exists(source))
+        {
+            return resolvedPackageIds;
+        }
+
+        var packageFiles = Directory.EnumerateFiles(source, "*.nupkg", SearchOption.TopDirectoryOnly)
+            .Select(GetPackageFileMetadata)
+            .OfType<PackageFileMetadata>()
+            .GroupBy(metadata => metadata.PackageId, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(
+                group => group.Key,
+                group => group.OrderByDescending(metadata => metadata.Version, SemVersion.PrecedenceComparer).First(),
+                StringComparer.OrdinalIgnoreCase);
+
+        var packagesToProcess = new Queue<string>(resolvedPackageIds);
+
+        while (packagesToProcess.Count > 0)
+        {
+            var currentPackageId = packagesToProcess.Dequeue();
+            if (!packageFiles.TryGetValue(currentPackageId, out var metadata))
+            {
+                continue;
+            }
+
+            foreach (var dependencyPackageId in GetDependencyPackageIds(metadata.PackageFilePath))
+            {
+                if (packageFiles.ContainsKey(dependencyPackageId) && resolvedPackageIds.Add(dependencyPackageId))
+                {
+                    packagesToProcess.Enqueue(dependencyPackageId);
+                }
+            }
+        }
+
+        return resolvedPackageIds;
+    }
+
+    private static PackageFileMetadata? GetPackageFileMetadata(string packageFile)
+    {
+        var packageIdentity = TryGetPackageIdentityFromPackageFileName(packageFile);
+        if (packageIdentity is null)
+        {
+            return null;
+        }
+
+        return new PackageFileMetadata(packageIdentity.Value.PackageId, packageIdentity.Value.Version, packageFile);
+    }
+
+    private static IEnumerable<string> GetDependencyPackageIds(string packageFile)
+    {
+        try
+        {
+            using var archive = ZipFile.OpenRead(packageFile);
+            var nuspecEntry = archive.Entries.FirstOrDefault(entry => entry.FullName.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase));
+            if (nuspecEntry is null)
+            {
+                return [];
+            }
+
+            using var stream = nuspecEntry.Open();
+            var document = XDocument.Load(stream);
+            return document
+                .Descendants()
+                .Where(element => element.Name.LocalName == "dependency")
+                .Select(element => element.Attribute("id")?.Value)
+                .Where(id => !string.IsNullOrWhiteSpace(id))
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Cast<string>()
+                .ToArray();
+        }
+        catch (IOException)
+        {
+            return [];
+        }
+        catch (InvalidDataException)
+        {
+            return [];
+        }
+        catch (System.Xml.XmlException)
+        {
+            return [];
+        }
+    }
+
+    private static (string PackageId, SemVersion Version)? TryGetPackageIdentityFromPackageFileName(string packageFile)
+    {
+        var packageFileName = Path.GetFileNameWithoutExtension(packageFile);
+        if (string.IsNullOrWhiteSpace(packageFileName))
+        {
+            return null;
+        }
+
+        var separatorIndex = packageFileName.IndexOf('.');
+        while (separatorIndex >= 0 && separatorIndex < packageFileName.Length - 1)
+        {
+            var versionCandidate = packageFileName[(separatorIndex + 1)..];
+            if (SemVersion.TryParse(versionCandidate, SemVersionStyles.Strict, out var version))
+            {
+                return (packageFileName[..separatorIndex], version);
+            }
+
+            separatorIndex = packageFileName.IndexOf('.', separatorIndex + 1);
+        }
+
+        return null;
+    }
+
+    private readonly record struct PackageFileMetadata(string PackageId, SemVersion Version, string PackageFilePath);
+
+    private static bool IsScopedAspireMapping(PackageMapping mapping)
+    {
+        return mapping.PackageFilter.StartsWith("Aspire", StringComparison.OrdinalIgnoreCase) &&
+            !string.Equals(mapping.PackageFilter, PackageMapping.AllPackages, StringComparison.Ordinal);
+    }
+
     public static PackageChannel CreateExplicitChannel(string name, PackageChannelQuality quality, PackageMapping[]? mappings, INuGetPackageCache nuGetPackageCache, bool configureGlobalPackagesFolder = false, string? cliDownloadBaseUrl = null, string? pinnedVersion = null)
     {
         return new PackageChannel(name, quality, mappings, nuGetPackageCache, configureGlobalPackagesFolder, cliDownloadBaseUrl, pinnedVersion);
@@ -207,4 +376,4 @@ public static PackageChannel CreateImplicitChannel(INuGetPackageCache nuGetPacka
         // for broader templating options.
         return new PackageChannel("default", PackageChannelQuality.Both, null, nuGetPackageCache);
     }
-}
+}

src/Aspire.Cli/Templating/DotNetTemplateFactory.cs

@@ -654,6 +654,7 @@ private async Task<string> GetOutputPathAsync(TemplateInputs inputs, Func<string
         }
 
         IEnumerable<PackageChannel> channels;
+        var hasPrHives = executionContext.GetPrHiveCount() > 0;
         bool hasChannelSetting = !string.IsNullOrEmpty(channelName);
 
         if (hasChannelSetting)
@@ -671,8 +672,7 @@ private async Task<string> GetOutputPathAsync(TemplateInputs inputs, Func<string
         {
             // If there are hives (PR build directories), include all channels.
             // Otherwise, only use the implicit/default channel to avoid prompting.
-            var hasHives = executionContext.GetPrHiveCount() > 0;
-            channels = hasHives 
+            channels = hasPrHives
                 ? allChannels 
                 : allChannels.Where(c => c.Type is PackageChannelType.Implicit);
         }
@@ -710,7 +710,17 @@ await Parallel.ForEachAsync(channels, cancellationToken, async (channel, ct) =>
             }
         }
 
-        // If channel was specified via --channel option or global setting (but no --version), 
+        if (VersionHelper.TryGetCurrentCliVersionMatch(
+            orderedPackagesFromChannels,
+            p => p.Package.Version,
+            out var cliVersionPackageFromChannel,
+            channelName: channelName,
+            hasPrHives: hasPrHives))
+        {
+            return cliVersionPackageFromChannel;
+        }
+
+        // If channel was specified via --channel option or global setting (but no --version),
         // automatically select the highest version from that channel without prompting
         if (hasChannelSetting)
         {