dependabot-nuget 0.285.0 → 0.287.0

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

@@ -13,6 +13,9 @@ public class RunWorker
 {
     private readonly IApiHandler _apiHandler;
     private readonly ILogger _logger;
+    private readonly IDiscoveryWorker _discoveryWorker;
+    private readonly IAnalyzeWorker _analyzeWorker;
+    private readonly IUpdaterWorker _updaterWorker;
 
     internal static readonly JsonSerializerOptions SerializerOptions = new()
     {
@@ -21,10 +24,13 @@ public class RunWorker
         Converters = { new JsonStringEnumConverter() },
     };
 
-    public RunWorker(IApiHandler apiHandler, ILogger logger)
+    public RunWorker(IApiHandler apiHandler, IDiscoveryWorker discoverWorker, IAnalyzeWorker analyzeWorker, IUpdaterWorker updateWorker, ILogger logger)
     {
         _apiHandler = apiHandler;
         _logger = logger;
+        _discoveryWorker = discoverWorker;
+        _analyzeWorker = analyzeWorker;
+        _updaterWorker = updateWorker;
     }
 
     public async Task RunAsync(FileInfo jobFilePath, DirectoryInfo repoContentsPath, string baseCommitSha, FileInfo outputFilePath)
@@ -55,12 +61,13 @@ public class RunWorker
         {
             MSBuildHelper.RegisterMSBuild(repoContentsPath.FullName, repoContentsPath.FullName);
 
+            var experimentsManager = ExperimentsManager.GetExperimentsManager(job.Experiments);
             var allDependencyFiles = new Dictionary<string, DependencyFile>();
             foreach (var directory in job.GetAllDirectories())
             {
                 var localPath = PathHelper.JoinPath(repoContentsPath.FullName, directory);
                 lastUsedPackageSourceUrls = NuGetContext.GetPackageSourceUrls(localPath);
-                var result = await RunForDirectory(job, repoContentsPath, directory, baseCommitSha);
+                var result = await RunForDirectory(job, repoContentsPath, directory, baseCommitSha, experimentsManager);
                 foreach (var dependencyFile in result.Base64DependencyFiles)
                 {
                     var uniqueKey = Path.GetFullPath(Path.Join(dependencyFile.Directory, dependencyFile.Name)).NormalizePathToUnix().EnsurePrefix("/");
@@ -102,10 +109,9 @@ public class RunWorker
         return runResult;
     }
 
-    private async Task<RunResult> RunForDirectory(Job job, DirectoryInfo repoContentsPath, string repoDirectory, string baseCommitSha)
+    private async Task<RunResult> RunForDirectory(Job job, DirectoryInfo repoContentsPath, string repoDirectory, string baseCommitSha, ExperimentsManager experimentsManager)
     {
-        var discoveryWorker = new DiscoveryWorker(_logger);
-        var discoveryResult = await discoveryWorker.RunAsync(repoContentsPath.FullName, repoDirectory);
+        var discoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, repoDirectory);
 
         _logger.Log("Discovery JSON content:");
         _logger.Log(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
@@ -128,23 +134,31 @@ public class RunWorker
             });
 
             // track original contents for later handling
-            foreach (var project in discoveryResult.Projects)
+            async Task TrackOriginalContentsAsync(string directory, string fileName, string? replacementFileName = null)
             {
-                // TODO: include global.json, etc.
-                var path = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/");
-                var localPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, project.FilePath);
-                var content = await File.ReadAllTextAsync(localPath);
-                originalDependencyFileContents[path] = content;
-
-                // track packages.config if it exists
-                var projectDirectory = Path.GetDirectoryName(project.FilePath);
-                var packagesConfigPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, projectDirectory, "packages.config");
-                var normalizedPackagesConfigPath = Path.Join(discoveryResult.Path, projectDirectory, "packages.config").NormalizePathToUnix().EnsurePrefix("/");
-                if (File.Exists(packagesConfigPath))
+                var repoFullPath = Path.Join(directory, fileName);
+                if (replacementFileName is not null)
+                {
+                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
+                }
+
+                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
+                var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
+
+                if (!File.Exists(localFullPath))
                 {
-                    var packagesConfigContent = await File.ReadAllTextAsync(packagesConfigPath);
-                    originalDependencyFileContents[normalizedPackagesConfigPath] = packagesConfigContent;
+                    return;
                 }
+
+                var content = await File.ReadAllTextAsync(localFullPath);
+                originalDependencyFileContents[repoFullPath] = content;
+            }
+
+            foreach (var project in discoveryResult.Projects)
+            {
+                await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath);
+                await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+                // TODO: include global.json, etc.
             }
 
             // do update
@@ -166,7 +180,6 @@ public class RunWorker
                         continue;
                     }
 
-                    var analyzeWorker = new AnalyzeWorker(_logger);
                     var dependencyInfo = new DependencyInfo()
                     {
                         Name = dependency.Name,
@@ -175,16 +188,18 @@ public class RunWorker
                         IgnoredVersions = [],
                         Vulnerabilities = [],
                     };
-                    var analysisResult = await analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
+                    var analysisResult = await _analyzeWorker.RunAsync(repoContentsPath.FullName, discoveryResult, dependencyInfo);
                     // TODO: log analysisResult
                     if (analysisResult.CanUpdate)
                     {
-                        var dependencyLocation = Path.GetFullPath(Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/"));
+                        var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath);
                         if (dependency.Type == DependencyType.PackagesConfig)
                         {
-                            dependencyLocation = Path.Combine(Path.GetDirectoryName(dependencyLocation)!, "packages.config");
+                            dependencyLocation = Path.Join(Path.GetDirectoryName(dependencyLocation)!, "packages.config");
                         }
 
+                        dependencyLocation = dependencyLocation.FullyNormalizedRootedPath();
+
                         // TODO: this is inefficient, but not likely causing a bottleneck
                         var previousDependency = discoveredUpdatedDependencies.Dependencies
                             .Single(d => d.Name == dependency.Name && d.Requirements.Single().File == dependencyLocation);
@@ -201,7 +216,7 @@ public class RunWorker
                                     Groups = previousDependency.Requirements.Single().Groups,
                                     Source = new RequirementSource()
                                     {
-                                        SourceUrl = analysisResult.UpdatedDependencies.Single(d => d.Name == dependency.Name).InfoUrl,
+                                        SourceUrl = analysisResult.UpdatedDependencies.FirstOrDefault(d => d.Name == dependency.Name)?.InfoUrl,
                                     },
                                 }
                             ],
@@ -209,9 +224,8 @@ public class RunWorker
                             PreviousRequirements = previousDependency.Requirements,
                         };
 
-                        var updateWorker = new UpdaterWorker(_logger);
-                        var dependencyFilePath = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix();
-                        var updateResult = await updateWorker.RunAsync(repoContentsPath.FullName, dependencyFilePath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: false);
+                        var dependencyFilePath = Path.Join(discoveryResult.Path, project.FilePath).FullyNormalizedRootedPath();
+                        var updateResult = await _updaterWorker.RunAsync(repoContentsPath.FullName, dependencyFilePath, dependency.Name, dependency.Version!, analysisResult.UpdatedVersion, isTransitive: false);
                         // TODO: need to report if anything was actually updated
                         if (updateResult.ErrorType is null || updateResult.ErrorType == ErrorType.None)
                         {
@@ -228,44 +242,41 @@ public class RunWorker
 
             // create PR - we need to manually check file contents; we can't easily use `git status` in tests
             var updatedDependencyFiles = new List<DependencyFile>();
-            foreach (var project in discoveryResult.Projects)
+            async Task AddUpdatedFileIfDifferentAsync(string directory, string fileName, string? replacementFileName = null)
             {
-                var projectPath = Path.Join(discoveryResult.Path, project.FilePath).NormalizePathToUnix().EnsurePrefix("/");
-                var localProjectPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, project.FilePath);
-                var updatedProjectContent = await File.ReadAllTextAsync(localProjectPath);
-                var originalProjectContent = originalDependencyFileContents[projectPath];
-
-                if (updatedProjectContent != originalProjectContent)
+                var repoFullPath = Path.Join(directory, fileName);
+                if (replacementFileName is not null)
                 {
-                    updatedDependencyFiles.Add(new DependencyFile()
-                    {
-                        Name = project.FilePath,
-                        Content = updatedProjectContent,
-                        Directory = Path.GetDirectoryName(projectPath)!.NormalizeUnixPathParts(),
-                    });
+                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
                 }
 
-                var projectDirectory = Path.GetDirectoryName(project.FilePath);
-                var packagesConfigPath = Path.Join(repoContentsPath.FullName, discoveryResult.Path, projectDirectory, "packages.config");
-                var normalizedPackagesConfigPath = Path.Join(discoveryResult.Path, projectDirectory, "packages.config").NormalizePathToUnix().EnsurePrefix("/");
+                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
+                var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
 
-                if (File.Exists(packagesConfigPath))
+                if (!File.Exists(localFullPath))
                 {
-                    var updatedPackagesConfigContent = await File.ReadAllTextAsync(packagesConfigPath);
-                    var originalPackagesConfigContent = originalDependencyFileContents[normalizedPackagesConfigPath];
+                    return;
+                }
 
-                    if (updatedPackagesConfigContent != originalPackagesConfigContent)
+                var originalContent = originalDependencyFileContents[repoFullPath];
+                var updatedContent = await File.ReadAllTextAsync(localFullPath);
+                if (updatedContent != originalContent)
+                {
+                    updatedDependencyFiles.Add(new DependencyFile()
                     {
-                        updatedDependencyFiles.Add(new DependencyFile()
-                        {
-                            Name = Path.Join(projectDirectory!, "packages.config"),
-                            Content = updatedPackagesConfigContent,
-                            Directory = Path.GetDirectoryName(normalizedPackagesConfigPath)!.NormalizeUnixPathParts(),
-                        });
-                    }
+                        Name = Path.GetFileName(repoFullPath),
+                        Directory = Path.GetDirectoryName(repoFullPath)!.NormalizePathToUnix(),
+                        Content = updatedContent,
+                    });
                 }
             }
 
+            foreach (var project in discoveryResult.Projects)
+            {
+                await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath);
+                await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+            }
+
             if (updatedDependencyFiles.Count > 0)
             {
                 var createPullRequest = new CreatePullRequest()
@@ -292,11 +303,15 @@ public class RunWorker
 
         var result = new RunResult()
         {
-            Base64DependencyFiles = originalDependencyFileContents.Select(kvp => new DependencyFile()
+            Base64DependencyFiles = originalDependencyFileContents.Select(kvp =>
             {
-                Name = Path.GetFileName(kvp.Key),
-                Content = Convert.ToBase64String(Encoding.UTF8.GetBytes(kvp.Value)),
-                Directory = Path.GetFullPath(Path.GetDirectoryName(kvp.Key)!).NormalizePathToUnix(),
+                var fullPath = kvp.Key.FullyNormalizedRootedPath();
+                return new DependencyFile()
+                {
+                    Name = Path.GetFileName(fullPath),
+                    Content = Convert.ToBase64String(Encoding.UTF8.GetBytes(kvp.Value)),
+                    Directory = Path.GetDirectoryName(fullPath)!.NormalizePathToUnix(),
+                };
             }).ToArray(),
             BaseCommitSha = baseCommitSha,
         };
@@ -308,7 +323,7 @@ public class RunWorker
         string GetFullRepoPath(string path)
         {
             // ensures `path\to\file` is `/path/to/file`
-            return Path.Join(discoveryResult.Path, path).NormalizePathToUnix().NormalizeUnixPathParts().EnsurePrefix("/");
+            return Path.Join(discoveryResult.Path, path).FullyNormalizedRootedPath();
         }
 
         var auxiliaryFiles = new List<string>();
@@ -328,7 +343,7 @@ public class RunWorker
         foreach (var project in discoveryResult.Projects)
         {
             var projectDirectory = Path.GetDirectoryName(project.FilePath);
-            var pathToPackagesConfig = Path.Join(pathToContents, discoveryResult.Path, projectDirectory, "packages.config").NormalizePathToUnix().EnsurePrefix("/");
+            var pathToPackagesConfig = Path.Join(pathToContents, discoveryResult.Path, projectDirectory, "packages.config");
 
             if (File.Exists(pathToPackagesConfig))
             {
@@ -346,7 +361,9 @@ public class RunWorker
                         Name = d.Name,
                         Requirements = d.IsTransitive ? [] : [new ReportedRequirement()
                         {
-                            File = d.Type == DependencyType.PackagesConfig ? Path.Combine(Path.GetDirectoryName(GetFullRepoPath(p.FilePath))!, "packages.config"): GetFullRepoPath(p.FilePath),
+                            File = d.Type == DependencyType.PackagesConfig
+                                ? Path.Join(Path.GetDirectoryName(GetFullRepoPath(p.FilePath))!, "packages.config").FullyNormalizedRootedPath()
+                                : GetFullRepoPath(p.FilePath),
                             Requirement = d.Version!,
                             Groups = ["dependencies"],
                         }],

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackageReferenceUpdater.cs

@@ -26,6 +26,7 @@ internal static class PackageReferenceUpdater
         string previousDependencyVersion,
         string newDependencyVersion,
         bool isTransitive,
+        ExperimentsManager experimentsManager,
         ILogger logger)
     {
         // PackageReference project; modify the XML directly
@@ -42,11 +43,7 @@ internal static class PackageReferenceUpdater
         }
 
         var peerDependencies = await GetUpdatedPeerDependenciesAsync(repoRootPath, projectPath, tfms, dependencyName, newDependencyVersion, logger);
-        if (MSBuildHelper.UseNewDependencySolver())
-        {
-            await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
-        }
-        else
+        if (experimentsManager.UseLegacyDependencySolver)
         {
             if (isTransitive)
             {
@@ -62,6 +59,10 @@ internal static class PackageReferenceUpdater
                 await UpdateTopLevelDepdendency(repoRootPath, buildFiles, tfms, dependencyName, previousDependencyVersion, newDependencyVersion, peerDependencies, logger);
             }
         }
+        else
+        {
+            await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
+        }
 
         if (!await AreDependenciesCoherentAsync(repoRootPath, projectPath, dependencyName, logger, buildFiles, tfms))
         {
@@ -673,11 +674,21 @@ internal static class PackageReferenceUpdater
         ProjectBuildFile buildFile,
         string packageName)
         => buildFile.PackageItemNodes.Where(e =>
-            string.Equals(
-                (e.GetAttributeOrSubElementValue("Include", StringComparison.OrdinalIgnoreCase) ?? e.GetAttributeOrSubElementValue("Update", StringComparison.OrdinalIgnoreCase))?.Trim(),
-                packageName,
-                StringComparison.OrdinalIgnoreCase) &&
-            (e.GetAttributeOrSubElementValue("Version", StringComparison.OrdinalIgnoreCase) ?? e.GetAttributeOrSubElementValue("VersionOverride", StringComparison.OrdinalIgnoreCase)) is not null);
+        {
+            // Attempt to get "Include" or "Update" attribute values
+            var includeOrUpdateValue = e.GetAttributeOrSubElementValue("Include", StringComparison.OrdinalIgnoreCase)
+                                    ?? e.GetAttributeOrSubElementValue("Update", StringComparison.OrdinalIgnoreCase);
+            // Trim and split if there's a valid value
+            var packageNames = includeOrUpdateValue?
+                                .Trim()
+                                .Split(';', StringSplitOptions.RemoveEmptyEntries)
+                                .Select(t => t.Trim())
+                                .Where(t => t.Equals(packageName.Trim(), StringComparison.OrdinalIgnoreCase));
+            // Check if there's a matching package name and a non-null version attribute
+            return packageNames?.Any() == true &&
+                (e.GetAttributeOrSubElementValue("Version", StringComparison.OrdinalIgnoreCase)
+                    ?? e.GetAttributeOrSubElementValue("VersionOverride", StringComparison.OrdinalIgnoreCase)) is not null;
+        });
 
     private static async Task<bool> AreDependenciesCoherentAsync(string repoRootPath, string projectPath, string dependencyName, ILogger logger, ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms)
     {

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/PackagesConfigUpdater.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using System.Xml.XPath;
 
@@ -213,8 +214,8 @@ internal static class PackagesConfigUpdater
         var hintPathSubString = $"{dependencyName}.{dependencyVersion}";
 
         string? partialPathMatch = null;
-        var hintPathNodes = projectBuildFile.Contents.Descendants().Where(e => e.IsHintPathNodeForDependency(dependencyName));
-        foreach (var hintPathNode in hintPathNodes)
+        var specificHintPathNodes = projectBuildFile.Contents.Descendants().Where(e => e.IsHintPathNodeForDependency(dependencyName)).ToArray();
+        foreach (var hintPathNode in specificHintPathNodes)
         {
             var hintPath = hintPathNode.GetContentValue();
             var hintPathSubStringLocation = hintPath.IndexOf(hintPathSubString, StringComparison.OrdinalIgnoreCase);
@@ -255,18 +256,49 @@ internal static class PackagesConfigUpdater
             if (hasPackage)
             {
                 // the dependency exists in the packages.config file, so it must be the second case
-                // the vast majority of projects found in the wild use this, and since we have nothing to look for, we'll just have to hope
-                partialPathMatch = "../packages";
+                // at this point there's no perfect way to determine what the packages path is, but there's a really good chance that
+                // for any given package it looks something like this:
+                //   ..\..\packages\Package.Name.[version]\lib\Tfm\Package.Name.dll
+                var genericHintPathNodes = projectBuildFile.Contents.Descendants().Where(IsHintPathNode).ToArray();
+                if (genericHintPathNodes.Length > 0)
+                {
+                    foreach (var hintPathNode in genericHintPathNodes)
+                    {
+                        var hintPath = hintPathNode.GetContentValue();
+                        var match = Regex.Match(hintPath, @"^(?<PackagesPath>.*)[/\\](?<PackageNameAndVersion>[^/\\]+)[/\\]lib[/\\](?<Tfm>[^/\\]+)[/\\](?<AssemblyName>[^/\\]+)$");
+                        // e.g.,                              ..\..\packages     \    Some.Package.1.2.3              \    lib\     net45          \   Some.Package.dll
+                        if (match.Success)
+                        {
+                            partialPathMatch = match.Groups["PackagesPath"].Value;
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    // we know the dependency is used, but we have absolutely no idea where the packages path is, so we'll default to something reasonable
+                    partialPathMatch = "../packages";
+                }
             }
         }
 
         return partialPathMatch?.NormalizePathToUnix();
     }
 
-    private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName)
+    private static bool IsHintPathNode(this IXmlElementSyntax element)
     {
         if (element.Name.Equals("HintPath", StringComparison.OrdinalIgnoreCase) &&
             element.Parent.Name.Equals("Reference", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    private static bool IsHintPathNodeForDependency(this IXmlElementSyntax element, string dependencyName)
+    {
+        if (element.IsHintPathNode())
         {
             // the include attribute will look like one of the following:
             //   <Reference Include="Some.Dependency, Version=1.0.0.0, Culture=neutral, PublicKeyToken=abcd">

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/UpdaterWorker.cs

@@ -7,8 +7,9 @@ using NuGetUpdater.Core.Updater;
 
 namespace NuGetUpdater.Core;
 
-public class UpdaterWorker
+public class UpdaterWorker : IUpdaterWorker
 {
+    private readonly ExperimentsManager _experimentsManager;
     private readonly ILogger _logger;
     private readonly HashSet<string> _processedProjectPaths = new(StringComparer.OrdinalIgnoreCase);
 
@@ -18,8 +19,9 @@ public class UpdaterWorker
         Converters = { new JsonStringEnumConverter() },
     };
 
-    public UpdaterWorker(ILogger logger)
+    public UpdaterWorker(ExperimentsManager experimentsManager, ILogger logger)
     {
+        _experimentsManager = experimentsManager;
         _logger = logger;
     }
 
@@ -221,7 +223,7 @@ public class UpdaterWorker
         }
 
         // Some repos use a mix of packages.config and PackageReference
-        await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _logger);
+        await PackageReferenceUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, _experimentsManager, _logger);
 
         // Update lock file if exists
         if (File.Exists(Path.Combine(Path.GetDirectoryName(projectPath), "packages.lock.json")))

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/MSBuildHelper.cs

@@ -261,7 +261,11 @@ internal static partial class MSBuildHelper
                 ? evaluationResult.EvaluatedValue.TrimStart('[', '(').TrimEnd(']', ')')
                 : evaluationResult.EvaluatedValue;
 
-            yield return new Dependency(name, packageVersion, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate);
+            // If at this point we have a semicolon in the name then split it and yield multiple dependencies.
+            foreach (var splitName in name.Split(';', StringSplitOptions.RemoveEmptyEntries))
+            {
+                yield return new Dependency(splitName.Trim(), packageVersion, dependencyType, EvaluationResult: evaluationResult, IsUpdate: isUpdate);
+            }
         }
     }
 
@@ -335,11 +339,6 @@ internal static partial class MSBuildHelper
         }
     }
 
-    internal static bool UseNewDependencySolver()
-    {
-        return Environment.GetEnvironmentVariable("UseNewNugetPackageResolver") == "true";
-    }
-
     internal static async Task<Dependency[]?> ResolveDependencyConflicts(string repoRoot, string projectPath, string targetFramework, Dependency[] packages, Dependency[] update, ILogger logger)
     {
         var tempDirectory = Directory.CreateTempSubdirectory("package-dependency-coherence_");

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/PathHelper.cs

@@ -63,6 +63,8 @@ internal static class PathHelper
         return result;
     }
 
+    public static string FullyNormalizedRootedPath(this string path) => path.NormalizePathToUnix().NormalizeUnixPathParts().EnsurePrefix("/");
+
     public static string GetFullPathFromRelative(string rootPath, string relativePath)
         => Path.GetFullPath(JoinPath(rootPath, relativePath.NormalizePathToUnix()));
 
@@ -85,6 +87,55 @@ internal static class PathHelper
         return candidatePaths.ToArray();
     }
 
+    /// <summary>
+    /// Resolves the case of the file path in a case-insensitive manner. Returns null if the file path is not found. file path must be a full path inside the repoRootPath.
+    /// </summary>
+    /// <param name="filePath">The file path to resolve.</param>
+    /// <param name="repoRootPath">The root path of the repository.</param>
+    public static string? ResolveCaseInsensitivePathInsideRepoRoot(string filePath, string repoRootPath)
+    {
+        if (string.IsNullOrEmpty(filePath) || string.IsNullOrEmpty(repoRootPath))
+        {
+            return null; // Invalid input
+        }
+
+        // Normalize paths
+        var normalizedFilePath = filePath.FullyNormalizedRootedPath();
+        var normalizedRepoRoot = repoRootPath.FullyNormalizedRootedPath();
+
+        // Ensure the file path starts with the repo root path
+        if (!normalizedFilePath.StartsWith(normalizedRepoRoot + "/", StringComparison.OrdinalIgnoreCase))
+        {
+            return null; // filePath is outside of repoRootPath
+        }
+
+        // Start resolving from the root path
+        var currentPath = normalizedRepoRoot;
+        var relativePath = normalizedFilePath.Substring(normalizedRepoRoot.Length).TrimStart('/');
+
+        foreach (var part in relativePath.Split('/'))
+        {
+            if (string.IsNullOrEmpty(part))
+            {
+                continue;
+            }
+
+            // Enumerate the current directory to find a case-insensitive match
+            var nextPath = Directory
+                .EnumerateFileSystemEntries(currentPath)
+                .FirstOrDefault(entry => string.Equals(Path.GetFileName(entry), part, StringComparison.OrdinalIgnoreCase));
+
+            if (nextPath == null)
+            {
+                return null; // Part of the path does not exist
+            }
+
+            currentPath = nextPath;
+        }
+
+        return currentPath; // Fully resolved path with correct casing
+    }
+
     /// <summary>
     /// Check in every directory from <paramref name="initialPath"/> up to <paramref name="rootPath"/> for the file specified in <paramref name="fileName"/>.
     /// </summary>