dependabot-nuget 0.398.0 → 0.400.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3df370cfa9828e959bf529b8a391e336d368cc0c87aab8393665a554fa5e4b48
-  data.tar.gz: d3e16c0df803153b916f442af358e42573b89cefff989e5da52524dad83affe4
+  metadata.gz: a29d38c1ed416c5fc9c810f3815f241789054754ff92ac4982bf65e9ef221488
+  data.tar.gz: 75c1ce1d121fc582d1ad2edbd1e3a35bb79e6955501984585643e455a85e4934
 SHA512:
-  metadata.gz: 0464c48c69bf48bbc512a314c8600b50822defbe997f387ab8f29f54bd9308b8598e0c31d84995c98c266740bb90be3b2e612f0ed69a5d52132f7b57c4c481fd
-  data.tar.gz: c7efa1a36e6b822254fa4caf97e4c9b891042df0c866c7e34c9e566be1a64e0f4b3635cf6169d0b0d0b7b3e66ad9331fd0076d8c8296bea347cd57c3569a27f1
+  metadata.gz: 525d56946331f53dabd8705aa5a903b2489b89e2ebf40a5cc3b514dbf4c28d93633e09a46330d8d0b0509e7feb2439a988a408dd4f01e5ce71cf4b4c6a7cbb41
+  data.tar.gz: 2bdbf0b8a2c5302646e50fa666a14b91567dfecc96713472a419f15407c1c7a7628470adec534c50edf342ac4f3356f90840bf1d8c65526f24660d6b005fd9c1

data/helpers/lib/NuGetUpdater/Directory.Packages.props

@@ -17,10 +17,10 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.9.0" />
     <PackageVersion Include="Microsoft.CSharp" Version="4.7.0" />
     <PackageVersion Include="Microsoft.Extensions.FileProviders.Abstractions" Version="10.0.12" />
-    <PackageVersion Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.12" />
     <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.12" />
     <PackageVersion Include="Microsoft.NET.StringTools" Version="$(MSBuildPackageVersion)" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.9.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.10.1" />
     <PackageVersion Include="Microsoft.VisualStudio.Setup.Configuration.Interop" Version="3.14.2075" />
     <PackageVersion Include="Microsoft.VisualStudio.SolutionPersistence" Version="1.0.52" />
     <PackageVersion Include="Microsoft.Web.Xdt" Version="3.2.11" />

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/AnalyzeWorker.cs

@@ -20,6 +20,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
     private readonly string _jobId;
     private readonly ExperimentsManager _experimentsManager;
     private readonly ILogger _logger;
+    private readonly PackageVersionsCache _packageVersionsCache = new();
 
     internal static readonly JsonSerializerOptions SerializerOptions = new()
     {
@@ -96,7 +97,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
 
         bool isProjectUpdateNecessary = IsUpdateNecessary(dependencyInfo, projectsWithDependency);
         var isUpdateNecessary = isProjectUpdateNecessary || dotnetToolsHasDependency || globalJsonHasDependency;
-        using var nugetContext = new NuGetContext(startingDirectory);
+        using var nugetContext = new NuGetContext(startingDirectory, packageVersionsCache: _packageVersionsCache);
         AnalysisResult analysisResult;
         if (isUpdateNecessary)
         {
@@ -120,6 +121,34 @@ public partial class AnalyzeWorker : IAnalyzeWorker
                     .ToImmutableArray()
                 : projectFrameworks;
 
+            ImmutableArray<Dependency> candidateUpdatedDependencies = [];
+            Func<NuGetVersion, Task<bool>>? candidateValidator = null;
+            if (isProjectUpdateNecessary)
+            {
+                candidateValidator = async candidateVersion =>
+                {
+                    try
+                    {
+                        candidateUpdatedDependencies = await FindUpdatedDependenciesAsync(
+                            repoRoot,
+                            discovery,
+                            dependenciesToUpdate,
+                            candidateVersion,
+                            nugetContext,
+                            _logger,
+                            CancellationToken.None);
+                        return true;
+                    }
+                    catch (DependencyNotFoundException ex)
+                    {
+                        _logger.Info(
+                            $"  Rejecting version {candidateVersion.ToNormalizedString()} because dependencies could not be found: " +
+                            $"{string.Join(", ", ex.Dependencies)}");
+                        return false;
+                    }
+                };
+            }
+
             _logger.Info($"  Finding updated version.");
             updatedVersion = await FindUpdatedVersionAsync(
                 startingDirectory,
@@ -128,6 +157,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
                 applicableTargetFrameworks,
                 nugetContext,
                 _logger,
+                candidateValidator,
                 CancellationToken.None);
 
             _logger.Info($"  Finding updated peer dependencies.");
@@ -137,14 +167,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
             }
             else if (isProjectUpdateNecessary)
             {
-                updatedDependencies = await FindUpdatedDependenciesAsync(
-                    repoRoot,
-                    discovery,
-                    dependenciesToUpdate,
-                    updatedVersion,
-                    nugetContext,
-                    _logger,
-                    CancellationToken.None);
+                updatedDependencies = candidateUpdatedDependencies;
             }
             else if (dotnetToolsHasDependency)
             {
@@ -232,6 +255,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         ImmutableArray<NuGetFramework> projectFrameworks,
         NuGetContext nugetContext,
         ILogger logger,
+        Func<NuGetVersion, Task<bool>>? candidateValidator,
         CancellationToken cancellationToken)
     {
         var versionResult = await VersionFinder.GetVersionsAsync(
@@ -250,6 +274,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
             findLowestVersion: dependencyInfo.IsVulnerable,
             nugetContext,
             logger,
+            candidateValidator,
             cancellationToken);
     }
 
@@ -261,6 +286,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         bool findLowestVersion,
         NuGetContext nugetContext,
         ILogger logger,
+        Func<NuGetVersion, Task<bool>>? candidateValidator,
         CancellationToken cancellationToken)
     {
         var versions = versionResult.GetVersions();
@@ -282,6 +308,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
             projectFrameworks,
             nugetContext,
             logger,
+            candidateValidator,
             cancellationToken);
     }
 
@@ -293,6 +320,7 @@ public partial class AnalyzeWorker : IAnalyzeWorker
         ImmutableArray<NuGetFramework> projectFrameworks,
         NuGetContext nugetContext,
         ILogger logger,
+        Func<NuGetVersion, Task<bool>>? candidateValidator,
         CancellationToken cancellationToken)
     {
         if (NuGetVersion.TryParse(versionString, out var currentVersion))
@@ -308,7 +336,15 @@ public partial class AnalyzeWorker : IAnalyzeWorker
             if (!isCompatible)
             {
                 // If the current package is incompatible, then don't check for compatibility.
-                return orderedVersions.First();
+                foreach (var version in orderedVersions)
+                {
+                    if (candidateValidator is null || await candidateValidator(version))
+                    {
+                        return version;
+                    }
+                }
+
+                return null;
             }
         }
 
@@ -328,7 +364,8 @@ public partial class AnalyzeWorker : IAnalyzeWorker
                 logger,
                 cancellationToken);
 
-            if (isCompatible)
+            if (isCompatible &&
+                (candidateValidator is null || await candidateValidator(version)))
             {
                 return version;
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/NuGetContext.cs

@@ -21,11 +21,13 @@ internal record NuGetContext : IDisposable
     public ImmutableArray<PackageSource> PackageSources { get; }
     public NuGet.Common.ILogger Logger { get; }
     private readonly Func<PackageSource, SourceRepository> _sourceRepositoryFactory;
+    private readonly PackageVersionsCache _packageVersionsCache;
 
     public NuGetContext(
         string? currentDirectory = null,
         NuGet.Common.ILogger? logger = null,
-        Func<PackageSource, SourceRepository>? sourceRepositoryFactory = null)
+        Func<PackageSource, SourceRepository>? sourceRepositoryFactory = null,
+        PackageVersionsCache? packageVersionsCache = null)
     {
         SourceCacheContext = new SourceCacheContext();
         PackageDownloadContext = new PackageDownloadContext(SourceCacheContext);
@@ -41,6 +43,7 @@ internal record NuGetContext : IDisposable
             .ToImmutableArray();
         Logger = logger ?? NullLogger.Instance;
         _sourceRepositoryFactory = sourceRepositoryFactory ?? Repository.Factory.GetCoreV3;
+        _packageVersionsCache = packageVersionsCache ?? new PackageVersionsCache();
     }
 
     public void Dispose()
@@ -71,6 +74,32 @@ internal record NuGetContext : IDisposable
         return infoUrl;
     }
 
+    internal SourceRepository GetSourceRepository(PackageSource source) => _sourceRepositoryFactory(source);
+
+    internal Task<PackageVersions> GetPackageVersionsAsync(
+        PackageSource source,
+        string packageId,
+        bool includePrerelease,
+        bool includeUnlisted,
+        MetadataResource metadataResource,
+        CancellationToken cancellationToken)
+    {
+        return _packageVersionsCache.GetVersionsAsync(
+            CurrentDirectory,
+            source,
+            packageId,
+            includePrerelease,
+            includeUnlisted,
+            token => metadataResource.GetVersions(
+                packageId,
+                includePrerelease,
+                includeUnlisted,
+                SourceCacheContext,
+                NullLogger.Instance,
+                token),
+            cancellationToken);
+    }
+
     private async Task<string?> FindPackageInfoUrlAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
     {
         var globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(Settings);
@@ -88,7 +117,7 @@ internal record NuGetContext : IDisposable
         foreach (var source in sources)
         {
             message.AppendLine($"  checking {source.Name}");
-            var sourceRepository = _sourceRepositoryFactory(source);
+            var sourceRepository = GetSourceRepository(source);
             var feed = await sourceRepository.GetResourceAsync<MetadataResource>(cancellationToken);
             if (feed is null)
             {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/PackageVersionsCache.cs

@@ -0,0 +1,91 @@
+using NuGet.Configuration;
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Analyze;
+
+internal sealed class PackageVersionsCache
+{
+    private readonly Dictionary<CacheKey, Task<PackageVersions>> _cache = [];
+    private readonly object _cacheLock = new();
+
+    public async Task<PackageVersions> GetVersionsAsync(
+        string currentDirectory,
+        PackageSource source,
+        string packageId,
+        bool includePrerelease,
+        bool includeUnlisted,
+        Func<CancellationToken, Task<IEnumerable<NuGetVersion>>> getVersionsAsync,
+        CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var key = new CacheKey(
+            Path.TrimEndingDirectorySeparator(Path.GetFullPath(currentDirectory)),
+            source.Name,
+            source.Source,
+            packageId.ToLowerInvariant(),
+            includePrerelease,
+            includeUnlisted);
+
+        Task<PackageVersions> versionsTask;
+        var createdLoad = false;
+        lock (_cacheLock)
+        {
+            if (_cache.TryGetValue(key, out var cachedTask))
+            {
+                versionsTask = cachedTask;
+            }
+            else
+            {
+                versionsTask = LoadVersionsAsync(getVersionsAsync, cancellationToken);
+                _cache.Add(key, versionsTask);
+                createdLoad = true;
+            }
+        }
+
+        try
+        {
+            return await versionsTask.WaitAsync(cancellationToken);
+        }
+        catch
+        {
+            if (!versionsTask.IsCompletedSuccessfully &&
+                (createdLoad || versionsTask.IsCanceled || versionsTask.IsFaulted))
+            {
+                lock (_cacheLock)
+                {
+                    if (_cache.TryGetValue(key, out var cachedTask) && ReferenceEquals(cachedTask, versionsTask))
+                    {
+                        _cache.Remove(key);
+                    }
+                }
+            }
+
+            throw;
+        }
+    }
+
+    private static async Task<PackageVersions> LoadVersionsAsync(
+        Func<CancellationToken, Task<IEnumerable<NuGetVersion>>> getVersionsAsync,
+        CancellationToken cancellationToken)
+    {
+        var versions = await getVersionsAsync(cancellationToken);
+        return new PackageVersions(versions.ToHashSet());
+    }
+
+    private sealed record CacheKey(
+        string CurrentDirectory,
+        string SourceName,
+        string SourceUrl,
+        string PackageId,
+        bool IncludePrerelease,
+        bool IncludeUnlisted);
+}
+
+internal sealed class PackageVersions(HashSet<NuGetVersion> items)
+{
+    public int Count => items.Count;
+    public IEnumerable<NuGetVersion> Items => items;
+
+    public bool Contains(NuGetVersion version) => items.Contains(version);
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Analyze/VersionFinder.cs

@@ -6,7 +6,6 @@ using NuGet.Common;
 using NuGet.Configuration;
 using NuGet.Frameworks;
 using NuGet.Packaging.Core;
-using NuGet.Protocol;
 using NuGet.Protocol.Core.Types;
 using NuGet.Versioning;
 
@@ -94,25 +93,18 @@ internal static class VersionFinder
 
         foreach (var source in sources)
         {
-            MetadataResource? feed = null;
             PackageMetadataResource? metadataResource = null;
+            PackageVersions feedVersions;
             try
             {
-                var sourceRepository = Repository.Factory.GetCoreV3(source);
-                feed = await sourceRepository.GetResourceAsync<MetadataResource>();
+                var sourceRepository = nugetContext.GetSourceRepository(source);
+                var feed = await sourceRepository.GetResourceAsync<MetadataResource>();
                 if (feed is null)
                 {
                     logger.Warn($"Failed to get {nameof(MetadataResource)} for [{source.Source}]");
                     continue;
                 }
 
-                var packageFinder = await sourceRepository.GetResourceAsync<FindPackageByIdResource>();
-                if (packageFinder is null)
-                {
-                    logger.Warn($"Failed to get {nameof(FindPackageByIdResource)} for [{source.Source}]");
-                    continue;
-                }
-
                 if (dependencyInfo.Cooldown is not null)
                 {
                     metadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>();
@@ -123,15 +115,14 @@ internal static class VersionFinder
                     }
                 }
 
-                // a non-compliant v2 API returning 404 can cause this to throw
-                var existsInFeed = await feed.Exists(
+                feedVersions = await nugetContext.GetPackageVersionsAsync(
+                    source,
                     dependencyInfo.Name,
                     includePrerelease,
                     includeUnlisted: false,
-                    nugetContext.SourceCacheContext,
-                    NullLogger.Instance,
+                    feed,
                     cancellationToken);
-                if (!existsInFeed)
+                if (feedVersions.Count == 0)
                 {
                     continue;
                 }
@@ -152,20 +143,12 @@ internal static class VersionFinder
                 throw new BadResponseException(ex.Message, source.Source);
             }
 
-            var feedVersions = (await feed.GetVersions(
-                dependencyInfo.Name,
-                includePrerelease,
-                includeUnlisted: false,
-                nugetContext.SourceCacheContext,
-                NullLogger.Instance,
-                CancellationToken.None)).ToHashSet();
-
             if (feedVersions.Contains(currentVersion))
             {
                 result.AddCurrentVersionSource(source);
             }
 
-            var versions = feedVersions.Where(versionFilter).ToArray();
+            var versions = feedVersions.Items.Where(versionFilter).ToArray();
             foreach (var version in versions)
             {
                 var packageIdentity = new PackageIdentity(dependencyInfo.Name, version);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/Condition.cs

@@ -1,11 +1,15 @@
 using System.Text.Json.Serialization;
 
+using NuGet.Versioning;
+
 using NuGetUpdater.Core.Analyze;
 
 namespace NuGetUpdater.Core.Run.ApiModel;
 
 public sealed record Condition
 {
+    private static readonly NuGetVersion MinimumVersion = NuGetVersion.Parse("0");
+
     [JsonPropertyName("dependency-name")]
     public required string DependencyName { get; init; }
     [JsonPropertyName("source")]
@@ -16,6 +20,19 @@ public sealed record Condition
     public DateTime? UpdatedAt { get; init; } = null;
     [JsonPropertyName("version-requirement")]
     public Requirement? VersionRequirement { get; init; } = null;
+
+    internal bool IsUnconditionalIgnore()
+    {
+        if ((UpdateTypes ?? []).Length > 0)
+        {
+            return false;
+        }
+
+        // Name-only ignore conditions are serialized by the service with a >= 0 requirement.
+        return VersionRequirement is null ||
+            VersionRequirement is IndividualRequirement { Operator: ">=", Version: var version } &&
+            version == MinimumVersion;
+    }
 }
 
 public enum ConditionUpdateType

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/DependencyGroup.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using System.IO.Enumeration;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 using NuGet.Versioning;
 
@@ -19,6 +20,42 @@ public record DependencyGroup
     public Dictionary<string, object> Rules { get; init; } = new();
 
     public GroupMatcher GetGroupMatcher() => GroupMatcher.FromRules(Rules);
+
+    public bool IsGroupedByDependencyName =>
+        GetString(Rules, "group-by")?.Equals("dependency-name", StringComparison.Ordinal) == true;
+
+    [JsonIgnore]
+    public string? DependencyNameGroupTarget { get; init; }
+
+    public DependencyGroup CreateDependencyNameSubgroup(string dependencyName, string? subgroupName = null)
+    {
+        var matchesParent = GetGroupMatcher().IsMatch(dependencyName);
+        var subgroupRules = new Dictionary<string, object>(Rules)
+        {
+            ["patterns"] = matchesParent ? new[] { dependencyName } : Array.Empty<string>(),
+        };
+        return this with
+        {
+            Name = subgroupName ?? $"{Name}/{dependencyName}",
+            Rules = subgroupRules,
+            DependencyNameGroupTarget = dependencyName,
+        };
+    }
+
+    private static string? GetString(Dictionary<string, object> rules, string propertyName)
+    {
+        if (!rules.TryGetValue(propertyName, out var propertyObject))
+        {
+            return null;
+        }
+
+        return propertyObject switch
+        {
+            string value => value,
+            JsonElement { ValueKind: JsonValueKind.String } element => element.GetString(),
+            _ => null,
+        };
+    }
 }
 
 public enum GroupUpdateType

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/Job.cs

@@ -102,7 +102,65 @@ public sealed record Job
         return existingPullRequests;
     }
 
-    public Tuple<string?, ImmutableArray<PullRequestDependency>>? GetExistingPullRequestForDependencies(IEnumerable<ReportedDependencyWithDirectory> dependencies, bool considerVersions)
+    public DependencyGroup? ResolveDependencyGroupToRefresh()
+    {
+        if (DependencyGroupToRefresh is null)
+        {
+            return null;
+        }
+
+        var exactGroup = FindConfiguredDependencyGroup(DependencyGroupToRefresh);
+        if (exactGroup is not null)
+        {
+            return exactGroup.IsGroupedByDependencyName ? null : exactGroup;
+        }
+
+        var dynamicParent = DependencyGroups
+            .Where(g => g.IsGroupedByDependencyName)
+            .Where(g => DependencyGroupToRefresh.StartsWith($"{g.Name}/", StringComparison.OrdinalIgnoreCase))
+            .OrderByDescending(g => g.Name.Length)
+            .FirstOrDefault();
+        if (dynamicParent is null)
+        {
+            return null;
+        }
+
+        var dependencyName = DependencyGroupToRefresh[(dynamicParent.Name.Length + 1)..];
+        if (dependencyName.Length == 0 ||
+            (Dependencies.Length > 0 && !Dependencies.Contains(dependencyName, StringComparer.OrdinalIgnoreCase)))
+        {
+            return null;
+        }
+
+        return dynamicParent.CreateDependencyNameSubgroup(dependencyName, DependencyGroupToRefresh);
+    }
+
+    public DependencyGroup? FindConfiguredDependencyGroup(string name)
+    {
+        return DependencyGroups.FirstOrDefault(g => g.Name == name) ??
+            DependencyGroups.FirstOrDefault(g => g.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+    }
+
+    public Tuple<string?, ImmutableArray<PullRequestDependency>>? GetExistingPullRequestForDependencies(
+        IEnumerable<ReportedDependencyWithDirectory> dependencies,
+        bool considerVersions)
+    {
+        return GetExistingPullRequestForDependencies(dependencies, considerVersions, dependencyGroupName: null, matchGroupName: false);
+    }
+
+    public Tuple<string?, ImmutableArray<PullRequestDependency>>? GetExistingGroupPullRequestForDependencies(
+        IEnumerable<ReportedDependencyWithDirectory> dependencies,
+        bool considerVersions,
+        string dependencyGroupName)
+    {
+        return GetExistingPullRequestForDependencies(dependencies, considerVersions, dependencyGroupName, matchGroupName: true);
+    }
+
+    private Tuple<string?, ImmutableArray<PullRequestDependency>>? GetExistingPullRequestForDependencies(
+        IEnumerable<ReportedDependencyWithDirectory> dependencies,
+        bool considerVersions,
+        string? dependencyGroupName,
+        bool matchGroupName)
     {
         var desiredDependencies = dependencies.ToArray();
         if (desiredDependencies.Any(d => d.Version is null))
@@ -128,6 +186,12 @@ public sealed record Job
         var existingPullRequest = existingPullRequests
             .FirstOrDefault(pr =>
             {
+                if (matchGroupName &&
+                    !string.Equals(pr.Item1, dependencyGroupName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return false;
+                }
+
                 return desiredDependencies.All(desired => pr.Item2.Any(existing => DependenciesMatch(desired, existing))) &&
                     pr.Item2.All(existing => desiredDependencies.Any(desired => DependenciesMatch(desired, existing)));
             });
@@ -137,7 +201,7 @@ public sealed record Job
     public bool IsDependencyIgnoredByNameOnly(string dependencyName)
     {
         var packageNamesToIgnore = IgnoreConditions
-            .Where(c => (c.UpdateTypes ?? []).Length == 0 && c.VersionRequirement is null) // ignoring by name means there can't be any qualification
+            .Where(c => c.IsUnconditionalIgnore())
             .Select(c => c.DependencyName)
             .ToArray();
         var isIgnored = packageNamesToIgnore

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/PullRequestTextGenerator.cs

@@ -14,9 +14,19 @@ public class PullRequestTextGenerator
 {
     private const int MaxTitleLength = 70;
 
-    public static string GetPullRequestTitle(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, string? dependencyGroupName)
+    public static string GetPullRequestTitle(
+        Job job,
+        ImmutableArray<UpdateOperationBase> updateOperationsPerformed,
+        string? dependencyGroupName,
+        string? dependencyNameGroupTarget = null,
+        IEnumerable<string>? updatedDirectories = null)
     {
-        var shortTitle = GetPullRequestShortTitle(job, updateOperationsPerformed, dependencyGroupName);
+        var shortTitle = GetPullRequestShortTitle(
+            job,
+            updateOperationsPerformed,
+            dependencyGroupName,
+            dependencyNameGroupTarget,
+            updatedDirectories);
         var titlePrefix = GetPullRequestTitlePrefix(job);
         var fullTitle = $"{titlePrefix}{shortTitle}";
         return fullTitle;
@@ -43,14 +53,31 @@ public class PullRequestTextGenerator
         return prefix;
     }
 
-    private static string GetPullRequestShortTitle(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, string? dependencyGroupName)
+    private static string GetPullRequestShortTitle(
+        Job job,
+        ImmutableArray<UpdateOperationBase> updateOperationsPerformed,
+        string? dependencyGroupName,
+        string? dependencyNameGroupTarget,
+        IEnumerable<string>? updatedDirectories)
     {
         string title;
         var dependencySets = GetDependencySets(updateOperationsPerformed);
-        if (dependencyGroupName is not null)
+        if (dependencyGroupName is not null && dependencyNameGroupTarget is null)
         {
             title = $"Bump the {dependencyGroupName} group with {dependencySets.Length} update{(dependencySets.Length > 1 ? "s" : "")}";
         }
+        else if (dependencyNameGroupTarget is not null)
+        {
+            var directories = (updatedDirectories ?? [])
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+            title = directories.Length switch
+            {
+                > 1 => $"Bump {dependencyNameGroupTarget} across {directories.Length} directories",
+                1 when directories[0] != "/" => $"Bump {dependencyNameGroupTarget} in {directories[0]}",
+                _ => $"Bump {dependencyNameGroupTarget}",
+            };
+        }
         else
         {
             if (dependencySets.Length == 1)
@@ -73,13 +100,23 @@ public class PullRequestTextGenerator
         return title;
     }
 
-    public static string GetPullRequestCommitMessage(Job job, ImmutableArray<UpdateOperationBase> updateOperationsPerformed, string? dependencyGroupName)
+    public static string GetPullRequestCommitMessage(
+        Job job,
+        ImmutableArray<UpdateOperationBase> updateOperationsPerformed,
+        string? dependencyGroupName,
+        string? dependencyNameGroupTarget = null,
+        IEnumerable<string>? updatedDirectories = null)
     {
         var sb = new StringBuilder();
-        sb.AppendLine(GetPullRequestTitle(job, updateOperationsPerformed, dependencyGroupName));
+        sb.AppendLine(GetPullRequestTitle(
+            job,
+            updateOperationsPerformed,
+            dependencyGroupName,
+            dependencyNameGroupTarget,
+            updatedDirectories));
         var dependencySets = GetDependencySets(updateOperationsPerformed);
         if (dependencySets.Length > 1 ||
-            dependencyGroupName is not null)
+            (dependencyGroupName is not null && dependencyNameGroupTarget is null))
         {
             // multiple updates performed, enumerate them
             sb.AppendLine();