dependabot-nuget 0.287.0 → 0.289.0

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

@@ -30,7 +30,7 @@ internal static class PackageReferenceUpdater
         ILogger logger)
     {
         // PackageReference project; modify the XML directly
-        logger.Log("  Running 'PackageReference' project direct XML update");
+        logger.Info("  Running 'PackageReference' project direct XML update");
 
         (ImmutableArray<ProjectBuildFile> buildFiles, string[] tfms) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
 
@@ -61,6 +61,11 @@ internal static class PackageReferenceUpdater
         }
         else
         {
+            if (peerDependencies is null)
+            {
+                return;
+            }
+
             await UpdateDependencyWithConflictResolution(repoRootPath, buildFiles, tfms, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive, peerDependencies, logger);
         }
 
@@ -105,7 +110,7 @@ internal static class PackageReferenceUpdater
                 var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflicts(repoRootPath, projectFile.Path, tfm, topLevelDependencies, dependenciesToUpdate, logger);
                 if (resolvedDependencies is null)
                 {
-                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    logger.Warn($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
                     continue;
                 }
 
@@ -184,14 +189,14 @@ internal static class PackageReferenceUpdater
         // Skip updating the project if the dependency does not exist in the graph
         if (!packageFound)
         {
-            logger.Log($"    Package [{dependencyName}] Does not exist as a dependency in [{projectPath}].");
+            logger.Info($"    Package [{dependencyName}] Does not exist as a dependency in [{projectPath}].");
             return false;
         }
 
         // Skip updating the project if the dependency version meets or exceeds the newDependencyVersion
         if (!needsUpdate)
         {
-            logger.Log($"    Package [{dependencyName}] already meets the requested dependency version in [{projectPath}].");
+            logger.Info($"    Package [{dependencyName}] already meets the requested dependency version in [{projectPath}].");
             return false;
         }
 
@@ -242,7 +247,7 @@ internal static class PackageReferenceUpdater
                                               a.Value.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)))
             .FirstOrDefault();
 
-        logger.Log($"    Pinning [{dependencyName}/{newDependencyVersion}] as a package version.");
+        logger.Info($"    Pinning [{dependencyName}/{newDependencyVersion}] as a package version.");
 
         var lastPackageVersion = directoryPackages.ItemNodes
             .Where(e => e.Name.Equals("PackageVersion", StringComparison.OrdinalIgnoreCase))
@@ -250,7 +255,7 @@ internal static class PackageReferenceUpdater
 
         if (lastPackageVersion is null)
         {
-            logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not pinned.");
+            logger.Info($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not pinned.");
             return;
         }
 
@@ -260,7 +265,7 @@ internal static class PackageReferenceUpdater
         if (existingPackageVersionElement is null)
         {
             // need to add a new entry
-            logger.Log("      New PackageVersion element added.");
+            logger.Info("      New PackageVersion element added.");
             var leadingTrivia = lastPackageVersion.AsNode.GetLeadingTrivia();
             var packageVersionElement = XmlExtensions.CreateSingleLineXmlElementSyntax("PackageVersion", new SyntaxList<SyntaxNode>(leadingTrivia))
                 .WithAttribute("Include", dependencyName)
@@ -274,19 +279,19 @@ internal static class PackageReferenceUpdater
             if (versionAttribute is null)
             {
                 // need to add the version
-                logger.Log("      Adding version attribute to element.");
+                logger.Info("      Adding version attribute to element.");
                 updatedPackageVersionElement = existingPackageVersionElement.WithAttribute("Version", newDependencyVersion);
             }
             else if (!versionAttribute.Value.Equals(newDependencyVersion, StringComparison.OrdinalIgnoreCase))
             {
                 // need to update the version
-                logger.Log($"      Updating version attribute of [{versionAttribute.Value}].");
+                logger.Info($"      Updating version attribute of [{versionAttribute.Value}].");
                 var updatedVersionAttribute = versionAttribute.WithValue(newDependencyVersion);
                 updatedPackageVersionElement = existingPackageVersionElement.ReplaceAttribute(versionAttribute, updatedVersionAttribute);
             }
             else
             {
-                logger.Log("      Existing PackageVersion element version was already correct.");
+                logger.Info("      Existing PackageVersion element version was already correct.");
                 return;
             }
 
@@ -302,15 +307,17 @@ internal static class PackageReferenceUpdater
         var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
         {
-            logger.Log($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
+            logger.Info($"    Adding [{dependencyName}/{newDependencyVersion}] as a top-level package reference.");
 
             // see https://learn.microsoft.com/nuget/consume-packages/install-use-packages-dotnet-cli
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["add", projectPath, "package", dependencyName, "--version", newDependencyVersion], workingDirectory: projectDirectory);
             MSBuildHelper.ThrowOnUnauthenticatedFeed(stdout);
             if (exitCode != 0)
             {
-                logger.Log($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
+                logger.Warn($"    Transitive dependency [{dependencyName}/{newDependencyVersion}] was not added.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
+
+            return exitCode;
         }, logger, retainMSBuildSdks: true);
     }
 
@@ -337,7 +344,7 @@ internal static class PackageReferenceUpdater
         var unupgradableTfms = tfmsAndDependencies.Where(kvp => !kvp.Value.Any()).Select(kvp => kvp.Key);
         if (unupgradableTfms.Any())
         {
-            logger.Log($"    The following target frameworks could not find packages to upgrade: {string.Join(", ", unupgradableTfms)}");
+            logger.Info($"    The following target frameworks could not find packages to upgrade: {string.Join(", ", unupgradableTfms)}");
             return null;
         }
 
@@ -352,7 +359,7 @@ internal static class PackageReferenceUpdater
                 if (packagesAndVersions.TryGetValue(packageName, out var existingVersion) &&
                     existingVersion != packageVersion)
                 {
-                    logger.Log($"    Package [{packageName}] tried to update to version [{packageVersion}], but found conflicting package version of [{existingVersion}].");
+                    logger.Info($"    Package [{packageName}] tried to update to version [{packageVersion}], but found conflicting package version of [{existingVersion}].");
                     conflictingPackageVersionsFound = true;
                 }
                 else
@@ -385,7 +392,7 @@ internal static class PackageReferenceUpdater
         var result = TryUpdateDependencyVersion(buildFiles, dependencyName, previousDependencyVersion, newDependencyVersion, logger);
         if (result == UpdateResult.NotFound)
         {
-            logger.Log($"    Root package [{dependencyName}/{previousDependencyVersion}] was not updated; skipping dependencies.");
+            logger.Info($"    Root package [{dependencyName}/{previousDependencyVersion}] was not updated; skipping dependencies.");
             return;
         }
 
@@ -403,7 +410,7 @@ internal static class PackageReferenceUpdater
                 var resolvedDependencies = await MSBuildHelper.ResolveDependencyConflictsWithBruteForce(repoRootPath, projectFile.Path, tfm, updatedTopLevelDependencies, logger);
                 if (resolvedDependencies is null)
                 {
-                    logger.Log($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
+                    logger.Info($"    Unable to resolve dependency conflicts for {projectFile.Path}.");
                     continue;
                 }
 
@@ -411,13 +418,13 @@ internal static class PackageReferenceUpdater
                 var specificResolvedDependency = resolvedDependencies.Where(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
                 if (specificResolvedDependency is null)
                 {
-                    logger.Log($"    Unable to resolve requested dependency for {dependencyName} in {projectFile.Path}.");
+                    logger.Info($"    Unable to resolve requested dependency for {dependencyName} in {projectFile.Path}.");
                     continue;
                 }
 
                 if (!newDependencyVersion.Equals(specificResolvedDependency.Version, StringComparison.OrdinalIgnoreCase))
                 {
-                    logger.Log($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
+                    logger.Info($"    Inconsistent resolution for {dependencyName}; attempted upgrade to {newDependencyVersion} but resolved {specificResolvedDependency.Version}.");
                     continue;
                 }
 
@@ -474,12 +481,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = versionAttribute.Value.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported [{packageNode.Name}] version attribute value [{versionAttribute.Value}] in [{buildFile.RelativePath}].");
+                            logger.Warn($"    Found unsupported [{packageNode.Name}] version attribute value [{versionAttribute.Value}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (string.Equals(currentVersion, previousDependencyVersion, StringComparison.Ordinal))
                         {
-                            logger.Log($"    Found incorrect [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                             updateNodes.Add(versionAttribute);
                         }
                         else if (previousDependencyVersion == null && NuGetVersion.TryParse(currentVersion, out var previousVersion))
@@ -489,13 +496,13 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                                 updateNodes.Add(versionAttribute);
                             }
                         }
                         else if (string.Equals(currentVersion, newDependencyVersion, StringComparison.Ordinal))
                         {
-                            logger.Log($"    Found correct [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct [{packageNode.Name}] version attribute in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -512,12 +519,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = versionValue.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported [{packageNode.Name}] version node value [{versionValue}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found unsupported [{packageNode.Name}] version node value [{versionValue}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (currentVersion == previousDependencyVersion)
                         {
-                            logger.Log($"    Found incorrect [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                             if (versionElement is XmlElementSyntax elementSyntax)
                             {
                                 updateNodes.Add(elementSyntax);
@@ -534,7 +541,7 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                                 if (versionElement is XmlElementSyntax elementSyntax)
                                 {
                                     updateNodes.Add(elementSyntax);
@@ -548,7 +555,7 @@ internal static class PackageReferenceUpdater
                         }
                         else if (currentVersion == newDependencyVersion)
                         {
-                            logger.Log($"    Found correct [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct [{packageNode.Name}] version node in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -556,7 +563,7 @@ internal static class PackageReferenceUpdater
                 else
                 {
                     // We weren't able to find the version node. Central package management?
-                    logger.Log("    Found package reference but was unable to locate version information.");
+                    logger.Warn("    Found package reference but was unable to locate version information.");
                 }
             }
 
@@ -624,12 +631,12 @@ internal static class PackageReferenceUpdater
                         var currentVersion = propertyContents.TrimStart('[', '(').TrimEnd(']', ')');
                         if (currentVersion.Contains(',') || currentVersion.Contains('*'))
                         {
-                            logger.Log($"    Found unsupported version property [{propertyElement.Name}] value [{propertyContents}] in [{buildFile.RelativePath}].");
+                            logger.Warn($"    Found unsupported version property [{propertyElement.Name}] value [{propertyContents}] in [{buildFile.RelativePath}].");
                             foundUnsupported = true;
                         }
                         else if (currentVersion == previousDependencyVersion)
                         {
-                            logger.Log($"    Found incorrect version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found incorrect version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                             updateProperties.Add((XmlElementSyntax)propertyElement.AsNode);
                         }
                         else if (previousDependencyVersion is null && NuGetVersion.TryParse(currentVersion, out var previousVersion))
@@ -639,13 +646,13 @@ internal static class PackageReferenceUpdater
                             {
                                 previousPackageVersion = currentVersion;
 
-                                logger.Log($"    Found incorrect peer version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                                logger.Info($"    Found incorrect peer version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                                 updateProperties.Add((XmlElementSyntax)propertyElement.AsNode);
                             }
                         }
                         else if (currentVersion == newDependencyVersion)
                         {
-                            logger.Log($"    Found correct version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
+                            logger.Info($"    Found correct version property [{propertyElement.Name}] in [{buildFile.RelativePath}].");
                             foundCorrect = true;
                         }
                     }
@@ -699,7 +706,7 @@ internal static class PackageReferenceUpdater
             var dependenciesAreCoherent = await MSBuildHelper.DependenciesAreCoherentAsync(repoRootPath, projectPath, tfm, updatedPackages, logger);
             if (!dependenciesAreCoherent)
             {
-                logger.Log($"    Package [{dependencyName}] could not be updated in [{projectPath}] because it would cause a dependency conflict.");
+                logger.Warn($"    Package [{dependencyName}] could not be updated in [{projectPath}] because it would cause a dependency conflict.");
                 return false;
             }
         }
@@ -713,7 +720,7 @@ internal static class PackageReferenceUpdater
         {
             if (await buildFile.SaveAsync())
             {
-                logger.Log($"    Saved [{buildFile.RelativePath}].");
+                logger.Info($"    Saved [{buildFile.RelativePath}].");
             }
         }
     }

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

@@ -9,6 +9,7 @@ using Microsoft.Language.Xml;
 using NuGet.CommandLine;
 
 using NuGetUpdater.Core.Updater;
+using NuGetUpdater.Core.Utilities;
 
 using Console = System.Console;
 
@@ -35,18 +36,18 @@ internal static class PackagesConfigUpdater
     )
     {
         // packages.config project; use NuGet.exe to perform update
-        logger.Log($"  Found '{NuGetHelper.PackagesConfigFileName}' project; running NuGet.exe update");
+        logger.Info($"  Found '{ProjectHelper.PackagesConfigFileName}' project; running NuGet.exe update");
 
         // ensure local packages directory exists
         var projectBuildFile = ProjectBuildFile.Open(repoRootPath, projectPath);
         var packagesSubDirectory = GetPathToPackagesDirectory(projectBuildFile, dependencyName, previousDependencyVersion, packagesConfigPath);
         if (packagesSubDirectory is null)
         {
-            logger.Log($"    Project [{projectPath}] does not reference this dependency.");
+            logger.Info($"    Project [{projectPath}] does not reference this dependency.");
             return;
         }
 
-        logger.Log($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
+        logger.Info($"    Using packages directory [{packagesSubDirectory}] for project [{projectPath}].");
 
         var projectDirectory = Path.GetDirectoryName(projectPath);
         var packagesDirectory = PathHelper.JoinPath(projectDirectory, packagesSubDirectory);
@@ -74,7 +75,7 @@ internal static class PackagesConfigUpdater
             "-NonInteractive",
         };
 
-        logger.Log("    Finding MSBuild...");
+        logger.Info("    Finding MSBuild...");
         var msbuildDirectory = MSBuildHelper.MSBuildPath;
         if (msbuildDirectory is not null)
         {
@@ -96,7 +97,7 @@ internal static class PackagesConfigUpdater
         // Update binding redirects
         await BindingRedirectManager.UpdateBindingRedirectsAsync(projectBuildFile, dependencyName, newDependencyVersion);
 
-        logger.Log("    Writing project file back to disk");
+        logger.Info("    Writing project file back to disk");
         await projectBuildFile.SaveAsync();
     }
 
@@ -118,12 +119,12 @@ internal static class PackagesConfigUpdater
             var retryingAfterRestore = false;
 
         doRestore:
-            logger.Log($"    Running NuGet.exe with args: {string.Join(" ", updateArgs)}");
+            logger.Info($"    Running NuGet.exe with args: {string.Join(" ", updateArgs)}");
             outputBuilder.Clear();
             var result = Program.Main(updateArgs.ToArray());
             var fullOutput = outputBuilder.ToString();
-            logger.Log($"    Result: {result}");
-            logger.Log($"    Output:\n{fullOutput}");
+            logger.Info($"    Result: {result}");
+            logger.Info($"    Output:\n{fullOutput}");
             if (result != 0)
             {
                 // The initial `update` command can fail for several reasons:
@@ -140,7 +141,7 @@ internal static class PackagesConfigUpdater
                 if (!retryingAfterRestore && OutputIndicatesRestoreIsRequired(fullOutput))
                 {
                     retryingAfterRestore = true;
-                    logger.Log($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
+                    logger.Info($"    Running NuGet.exe with args: {string.Join(" ", restoreArgs)}");
                     outputBuilder.Clear();
                     var exitCodeAgain = Program.Main(restoreArgs.ToArray());
                     var restoreOutput = outputBuilder.ToString();
@@ -164,7 +165,7 @@ internal static class PackagesConfigUpdater
         }
         catch (Exception e)
         {
-            logger.Log($"Error: {e}");
+            logger.Info($"Error: {e}");
             throw;
         }
         finally
@@ -178,7 +179,7 @@ internal static class PackagesConfigUpdater
             var deltaSpawnedProcesses = currentSpawnedProcesses.Except(existingSpawnedProcesses).ToArray();
             foreach (var credProvider in deltaSpawnedProcesses)
             {
-                logger.Log($"Ending spawned credential provider process");
+                logger.Info($"Ending spawned credential provider process");
                 credProvider.Kill();
             }
         }

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

@@ -4,6 +4,7 @@ using System.Text.Json.Serialization;
 
 using NuGetUpdater.Core.Analyze;
 using NuGetUpdater.Core.Updater;
+using NuGetUpdater.Core.Utilities;
 
 namespace NuGetUpdater.Core;
 
@@ -114,11 +115,11 @@ public class UpdaterWorker : IUpdaterWorker
                 await RunForProjectAsync(repoRootPath, workspacePath, dependencyName, previousDependencyVersion, newDependencyVersion, isTransitive);
                 break;
             default:
-                _logger.Log($"File extension [{extension}] is not supported.");
+                _logger.Info($"File extension [{extension}] is not supported.");
                 break;
         }
 
-        _logger.Log("Update complete.");
+        _logger.Info("Update complete.");
 
         _processedProjectPaths.Clear();
         return new UpdateOperationResult();
@@ -126,7 +127,7 @@ public class UpdaterWorker : IUpdaterWorker
 
     internal static async Task WriteResultFile(UpdateOperationResult result, string resultOutputPath, ILogger logger)
     {
-        logger.Log($"  Writing update result to [{resultOutputPath}].");
+        logger.Info($"  Writing update result to [{resultOutputPath}].");
 
         var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
         await File.WriteAllTextAsync(resultOutputPath, resultJson);
@@ -140,7 +141,7 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
+        _logger.Info($"Running for solution [{Path.GetRelativePath(repoRootPath, solutionPath)}]");
         var projectPaths = MSBuildHelper.GetProjectPathsFromSolution(solutionPath);
         foreach (var projectPath in projectPaths)
         {
@@ -156,10 +157,10 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for proj file [{Path.GetRelativePath(repoRootPath, projFilePath)}]");
+        _logger.Info($"Running for proj file [{Path.GetRelativePath(repoRootPath, projFilePath)}]");
         if (!File.Exists(projFilePath))
         {
-            _logger.Log($"File [{projFilePath}] does not exist.");
+            _logger.Info($"File [{projFilePath}] does not exist.");
             return;
         }
 
@@ -182,10 +183,10 @@ public class UpdaterWorker : IUpdaterWorker
         string newDependencyVersion,
         bool isTransitive)
     {
-        _logger.Log($"Running for project file [{Path.GetRelativePath(repoRootPath, projectPath)}]");
+        _logger.Info($"Running for project file [{Path.GetRelativePath(repoRootPath, projectPath)}]");
         if (!File.Exists(projectPath))
         {
-            _logger.Log($"File [{projectPath}] does not exist.");
+            _logger.Info($"File [{projectPath}] does not exist.");
             return;
         }
 
@@ -215,18 +216,21 @@ public class UpdaterWorker : IUpdaterWorker
 
         _processedProjectPaths.Add(projectPath);
 
-        _logger.Log($"Updating project [{projectPath}]");
+        _logger.Info($"Updating project [{projectPath}]");
 
-        if (NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
+        var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath, ProjectHelper.PathFormat.Full);
+        var packagesConfigFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+        if (packagesConfigFullPath is not null)
         {
-            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigPath, _logger);
+            await PackagesConfigUpdater.UpdateDependencyAsync(repoRootPath, projectPath, dependencyName, previousDependencyVersion, newDependencyVersion, packagesConfigFullPath, _logger);
         }
 
         // Some repos use a mix of packages.config and PackageReference
         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")))
+        var packagesLockFullPath = additionalFiles.Where(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesLockJsonFileName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+        if (packagesLockFullPath is not null)
         {
             await LockFileUpdater.UpdateLockFileAsync(repoRootPath, projectPath, _logger);
         }

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

@@ -0,0 +1,17 @@
+using Newtonsoft.Json.Linq;
+
+namespace NuGetUpdater.Core.Utilities;
+
+public static class CollectionExtensions
+{
+    public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key, Func<TValue> valueFactory) where TKey : notnull
+    {
+        if (!dictionary.TryGetValue(key, out var value))
+        {
+            value = valueFactory();
+            dictionary[key] = value;
+        }
+
+        return value;
+    }
+}

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

@@ -2,7 +2,7 @@ namespace NuGetUpdater.Core;
 
 public sealed class ConsoleLogger : ILogger
 {
-    public void Log(string message)
+    public void LogRaw(string message)
     {
         Console.WriteLine(message);
     }

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

@@ -136,7 +136,7 @@ public class PackageManager
     }
 
     // Method to get the dependencies of a package
-    public async Task<List<PackageToUpdate>> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory)
+    public async Task<List<PackageToUpdate>> GetDependenciesAsync(PackageToUpdate package, string targetFramework, string projectDirectory, ILogger logger)
     {
         if (!NuGetVersion.TryParse(package.NewVersion, out var otherVersion))
         {
@@ -235,24 +235,24 @@ public class PackageManager
             }
             else
             {
-                Console.WriteLine("No compatible framework found.");
+                logger.Info("No compatible framework found.");
             }
         }
         catch (HttpRequestException ex)
         {
-            Console.WriteLine($"HTTP error occurred: {ex.Message}");
+            logger.Error($"HTTP error occurred: {ex.Message}");
         }
         catch (ArgumentNullException ex)
         {
-            Console.WriteLine($"Argument is null error: {ex.ParamName}, {ex.Message}");
+            logger.Error($"Argument is null error: {ex.ParamName}, {ex.Message}");
         }
         catch (InvalidOperationException ex)
         {
-            Console.WriteLine($"Invalid operation exception: {ex.Message}");
+            logger.Error($"Invalid operation exception: {ex.Message}");
         }
         catch (Exception ex)
         {
-            Console.WriteLine($"An error occurred: {ex.Message}");
+            logger.Error($"An error occurred: {ex.Message}");
         }
 
         return dependencyList;
@@ -287,12 +287,12 @@ public class PackageManager
     }
 
     // Method to get the dependencies of a package and add them as a dependency
-    public async Task PopulatePackageDependenciesAsync(List<PackageToUpdate> packages, string targetFramework, string projectDirectory)
+    public async Task PopulatePackageDependenciesAsync(List<PackageToUpdate> packages, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Loop through each package and get their dependencies
         foreach (PackageToUpdate package in packages)
         {
-            List<PackageToUpdate> dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory);
+            List<PackageToUpdate> dependencies = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
             if (dependencies == null)
             {
@@ -366,7 +366,7 @@ public class PackageManager
                 package.CurrentVersion = package.NewVersion;
 
                 // Check if the current package has dependencies 
-                List<PackageToUpdate> dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory);
+                List<PackageToUpdate> dependencyList = await GetDependenciesAsync(package, targetFramework, projectDirectory, logger);
 
                 // If there are dependencies
                 if (dependencyList != null)
@@ -426,7 +426,7 @@ public class PackageManager
 
                 foreach (PackageToUpdate parent in parentPackages)
                 {
-                    bool isCompatible = await IsCompatibleAsync(parent, package, targetFramework, projectDirectory);
+                    bool isCompatible = await IsCompatibleAsync(parent, package, targetFramework, projectDirectory, logger);
 
                     // If the parent and package are not compatible
                     if (!isCompatible)
@@ -446,7 +446,7 @@ public class PackageManager
                     // If it's compatible and the package you updated wasn't in the existing package, check if the parent's dependencies version is the same as the current version
                     else if (isCompatible == true && inExisting == false)
                     {
-                        List<PackageToUpdate> dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+                        List<PackageToUpdate> dependencyListParent = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
 
                         PackageToUpdate parentDependency = dependencyListParent.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
@@ -478,7 +478,7 @@ public class PackageManager
                                 parent.NewVersion = parentVersion;
 
                                 // Check if the parent needs to be updated since the child isn't in the existing package list  and the parent can update to a newer version to remove the dependency
-                                List<PackageToUpdate> dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+                                List<PackageToUpdate> dependencyListParentTemp = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
                                 PackageToUpdate parentDependencyTemp = dependencyListParentTemp.FirstOrDefault(p => string.Compare(p.PackageName, package.PackageName, StringComparison.OrdinalIgnoreCase) == 0);
 
                                 // If the newer package version of the parent has the same version as the parent's previous dependency, update
@@ -499,7 +499,7 @@ public class PackageManager
 
             else
             {
-                Console.WriteLine("Current version is >= latest version");
+                logger.Info("Current version is >= latest version");
             }
         }
         catch
@@ -511,10 +511,10 @@ public class PackageManager
     }
 
     // Method to determine if a parent and child are compatible with their versions
-    public async Task<bool> IsCompatibleAsync(PackageToUpdate parent, PackageToUpdate child, string targetFramework, string projectDirectory)
+    public async Task<bool> IsCompatibleAsync(PackageToUpdate parent, PackageToUpdate child, string targetFramework, string projectDirectory, ILogger logger)
     {
         // Get the dependencies of the parent
-        List<PackageToUpdate> dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory);
+        List<PackageToUpdate> dependencies = await GetDependenciesAsync(parent, targetFramework, projectDirectory, logger);
 
         foreach (PackageToUpdate dependency in dependencies)
         {
@@ -613,7 +613,7 @@ public class PackageManager
             }
 
             // Check if there's compatibility with parent and dependency
-            if (await IsCompatibleAsync(possibleParent, possibleDependency, targetFramework, nugetContext.CurrentDirectory))
+            if (await IsCompatibleAsync(possibleParent, possibleDependency, targetFramework, nugetContext.CurrentDirectory, logger))
             {
                 // Check if parents are compatible, recursively
                 if (await AreAllParentsCompatibleAsync(existingPackages, possibleParent, targetFramework, nugetContext.CurrentDirectory, logger))
@@ -641,7 +641,7 @@ public class PackageManager
         foreach (PackageToUpdate parent in parentPackages)
         {
             // Check compatibility between the possibleParent and current parent
-            bool isCompatible = await IsCompatibleAsync(parent, possibleParent, targetFramework, projectDirectory);
+            bool isCompatible = await IsCompatibleAsync(parent, possibleParent, targetFramework, projectDirectory, logger);
 
             // If the possibleParent and parent are not compatible
             if (!isCompatible)
@@ -668,7 +668,7 @@ public class PackageManager
     }
 
     // Method to update the existing packages with new version of the desired packages to update
-    public void UpdateExistingPackagesWithNewVersions(List<PackageToUpdate> existingPackages, List<PackageToUpdate> packagesToUpdate)
+    public void UpdateExistingPackagesWithNewVersions(List<PackageToUpdate> existingPackages, List<PackageToUpdate> packagesToUpdate, ILogger logger)
     {
         foreach (PackageToUpdate packageToUpdate in packagesToUpdate)
         {
@@ -680,7 +680,7 @@ public class PackageManager
             }
             else
             {
-                Console.WriteLine($"Package {packageToUpdate.PackageName} not found in existing packages");
+                logger.Info($"Package {packageToUpdate.PackageName} not found in existing packages");
             }
         }
     }