dependabot-nuget 0.251.0 → 0.253.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DiscoveryWorker.cs

@@ -0,0 +1,217 @@
+using System.Collections.Immutable;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using NuGetUpdater.Core.Utilities;
+
+namespace NuGetUpdater.Core.Discover;
+
+public partial class DiscoveryWorker
+{
+    public const string DiscoveryResultFileName = "./.dependabot/discovery.json";
+
+    private readonly Logger _logger;
+    private readonly HashSet<string> _processedProjectPaths = new(StringComparer.OrdinalIgnoreCase); private readonly HashSet<string> _restoredMSBuildSdks = new(StringComparer.OrdinalIgnoreCase);
+
+    internal static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = true,
+        Converters = { new JsonStringEnumConverter() },
+    };
+
+    public DiscoveryWorker(Logger logger)
+    {
+        _logger = logger;
+    }
+
+    public async Task RunAsync(string repoRootPath, string workspacePath, string outputPath)
+    {
+        MSBuildHelper.RegisterMSBuild(Environment.CurrentDirectory, repoRootPath);
+
+        // When running under unit tests, the workspace path may not be rooted.
+        if (!Path.IsPathRooted(workspacePath) || !Directory.Exists(workspacePath))
+        {
+            workspacePath = Path.GetFullPath(Path.Join(repoRootPath, workspacePath));
+        }
+        else if (workspacePath == "/")
+        {
+            workspacePath = repoRootPath;
+        }
+
+        DotNetToolsJsonDiscoveryResult? dotNetToolsJsonDiscovery = null;
+        GlobalJsonDiscoveryResult? globalJsonDiscovery = null;
+        DirectoryPackagesPropsDiscoveryResult? directoryPackagesPropsDiscovery = null;
+
+        ImmutableArray<ProjectDiscoveryResult> projectResults = [];
+
+        if (Directory.Exists(workspacePath))
+        {
+            _logger.Log($"Discovering build files in workspace [{workspacePath}].");
+
+            dotNetToolsJsonDiscovery = DotNetToolsJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
+            globalJsonDiscovery = GlobalJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
+
+            if (globalJsonDiscovery is not null)
+            {
+                await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, globalJsonDiscovery.Dependencies, _logger);
+            }
+
+            projectResults = await RunForDirectoryAsnyc(repoRootPath, workspacePath);
+
+            directoryPackagesPropsDiscovery = DirectoryPackagesPropsDiscovery.Discover(repoRootPath, workspacePath, projectResults, _logger);
+
+            if (directoryPackagesPropsDiscovery is not null)
+            {
+                projectResults = projectResults.Remove(projectResults.First(p => p.FilePath.Equals(directoryPackagesPropsDiscovery.FilePath, StringComparison.OrdinalIgnoreCase)));
+            }
+        }
+        else
+        {
+            _logger.Log($"Workspace path [{workspacePath}] does not exist.");
+        }
+
+        var result = new WorkspaceDiscoveryResult
+        {
+            FilePath = repoRootPath != workspacePath ? Path.GetRelativePath(repoRootPath, workspacePath) : string.Empty,
+            DotNetToolsJson = dotNetToolsJsonDiscovery,
+            GlobalJson = globalJsonDiscovery,
+            DirectoryPackagesProps = directoryPackagesPropsDiscovery,
+            Projects = projectResults.OrderBy(p => p.FilePath).ToImmutableArray(),
+        };
+
+        await WriteResults(repoRootPath, outputPath, result);
+
+        _logger.Log("Discovery complete.");
+
+        _processedProjectPaths.Clear();
+    }
+
+    /// <summary>
+    /// Restores MSBuild SDKs from the given dependencies.
+    /// </summary>
+    /// <returns>Returns `true` when SDKs were restored successfully.</returns>
+    private async Task<bool> TryRestoreMSBuildSdksAsync(string repoRootPath, string workspacePath, ImmutableArray<Dependency> dependencies, Logger logger)
+    {
+        var msbuildSdks = dependencies
+            .Where(d => d.Type == DependencyType.MSBuildSdk && !string.IsNullOrEmpty(d.Version))
+            .Where(d => !d.Name.Equals("Microsoft.NET.Sdk", StringComparison.OrdinalIgnoreCase))
+            .Where(d => !_restoredMSBuildSdks.Contains($"{d.Name}/{d.Version}"))
+            .ToImmutableArray();
+
+        if (msbuildSdks.Length == 0)
+        {
+            return false;
+        }
+
+        var keys = msbuildSdks.Select(d => $"{d.Name}/{d.Version}");
+
+        _restoredMSBuildSdks.AddRange(keys);
+
+        _logger.Log($"  Restoring MSBuild SDKs: {string.Join(", ", keys)}");
+
+        return await NuGetHelper.DownloadNuGetPackagesAsync(repoRootPath, workspacePath, msbuildSdks, logger);
+    }
+
+    private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForDirectoryAsnyc(string repoRootPath, string workspacePath)
+    {
+        _logger.Log($"  Discovering projects beneath [{Path.GetRelativePath(repoRootPath, workspacePath)}].");
+        var projectPaths = FindProjectFiles(workspacePath);
+        if (projectPaths.IsEmpty)
+        {
+            _logger.Log("  No project files found.");
+            return [];
+        }
+
+        return await RunForProjectPathsAsync(repoRootPath, workspacePath, projectPaths);
+    }
+
+    private static ImmutableArray<string> FindProjectFiles(string workspacePath)
+    {
+        return Directory.EnumerateFiles(workspacePath, "*.*proj", SearchOption.AllDirectories)
+            .Where(path =>
+            {
+                var extension = Path.GetExtension(path).ToLowerInvariant();
+                return extension == ".proj" || extension == ".csproj" || extension == ".fsproj" || extension == ".vbproj";
+            })
+            .ToImmutableArray();
+    }
+
+    private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForProjectPathsAsync(string repoRootPath, string workspacePath, IEnumerable<string> projectPaths)
+    {
+        var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.OrdinalIgnoreCase);
+        foreach (var projectPath in projectPaths)
+        {
+            // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
+            if (!File.Exists(projectPath))
+            {
+                continue;
+            }
+
+            if (_processedProjectPaths.Contains(projectPath))
+            {
+                continue;
+            }
+            _processedProjectPaths.Add(projectPath);
+
+            var relativeProjectPath = Path.GetRelativePath(workspacePath, projectPath);
+            var packagesConfigDependencies = PackagesConfigDiscovery.Discover(workspacePath, projectPath, _logger)
+                    ?.Dependencies;
+
+            var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _logger);
+
+            // Determine if there were unrestored MSBuildSdks
+            var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
+            if (msbuildSdks.Length > 0)
+            {
+                // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
+                if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
+                {
+                    projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, projectPath, _logger);
+                }
+            }
+
+            foreach (var projectResult in projectResults)
+            {
+                if (results.ContainsKey(projectResult.FilePath))
+                {
+                    continue;
+                }
+
+                // If we had packages.config dependencies, merge them with the project dependencies
+                if (projectResult.FilePath == relativeProjectPath && packagesConfigDependencies is not null)
+                {
+                    packagesConfigDependencies = packagesConfigDependencies.Value
+                        .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
+                        .ToImmutableArray();
+
+                    results[projectResult.FilePath] = projectResult with
+                    {
+                        Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
+                    };
+                }
+                else
+                {
+                    results[projectResult.FilePath] = projectResult;
+                }
+            }
+        }
+
+        return [.. results.Values];
+    }
+
+    private static async Task WriteResults(string repoRootPath, string outputPath, WorkspaceDiscoveryResult result)
+    {
+        var resultPath = Path.IsPathRooted(outputPath)
+            ? outputPath
+            : Path.GetFullPath(outputPath, repoRootPath);
+
+        var resultDirectory = Path.GetDirectoryName(resultPath)!;
+        if (!Directory.Exists(resultDirectory))
+        {
+            Directory.CreateDirectory(resultDirectory);
+        }
+
+        var resultJson = JsonSerializer.Serialize(result, SerializerOptions);
+        await File.WriteAllTextAsync(path: resultPath, resultJson);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DotNetToolsJsonDiscovery.cs

@@ -0,0 +1,30 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+internal static class DotNetToolsJsonDiscovery
+{
+    public static DotNetToolsJsonDiscoveryResult? Discover(string repoRootPath, string workspacePath, Logger logger)
+    {
+        if (!MSBuildHelper.TryGetDotNetToolsJsonPath(repoRootPath, workspacePath, out var dotnetToolsJsonPath))
+        {
+            logger.Log("  No dotnet-tools.json file found.");
+            return null;
+        }
+
+        var dotnetToolsJsonFile = DotNetToolsJsonBuildFile.Open(workspacePath, dotnetToolsJsonPath, logger);
+
+        logger.Log($"  Discovered [{dotnetToolsJsonFile.RelativePath}] file.");
+
+        var dependencies = BuildFile.GetDependencies(dotnetToolsJsonFile)
+            .OrderBy(d => d.Name)
+            .ToImmutableArray();
+
+        return new()
+        {
+            FilePath = dotnetToolsJsonFile.RelativePath,
+            IsSuccess = !dotnetToolsJsonFile.FailedToParse,
+            Dependencies = dependencies,
+        };
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DotNetToolsJsonDiscoveryResult.cs

@@ -0,0 +1,10 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public sealed record DotNetToolsJsonDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<Dependency> Dependencies { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/GlobalJsonDiscovery.cs

@@ -0,0 +1,30 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+internal static class GlobalJsonDiscovery
+{
+    public static GlobalJsonDiscoveryResult? Discover(string repoRootPath, string workspacePath, Logger logger)
+    {
+        if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
+        {
+            logger.Log("  No global.json file found.");
+            return null;
+        }
+
+        var globalJsonFile = GlobalJsonBuildFile.Open(workspacePath, globalJsonPath, logger);
+
+        logger.Log($"  Discovered [{globalJsonFile.RelativePath}] file.");
+
+        var dependencies = BuildFile.GetDependencies(globalJsonFile)
+            .OrderBy(d => d.Name)
+            .ToImmutableArray();
+
+        return new()
+        {
+            FilePath = globalJsonFile.RelativePath,
+            IsSuccess = !globalJsonFile.FailedToParse,
+            Dependencies = dependencies,
+        };
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/GlobalJsonDiscoveryResult.cs

@@ -0,0 +1,10 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public sealed record GlobalJsonDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<Dependency> Dependencies { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/IDiscoveryResult.cs

@@ -0,0 +1,14 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public interface IDiscoveryResult
+{
+    string FilePath { get; }
+    bool IsSuccess { get; }
+}
+
+public interface IDiscoveryResultWithDependencies : IDiscoveryResult
+{
+    ImmutableArray<Dependency> Dependencies { get; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/PackagesConfigDiscovery.cs

@@ -0,0 +1,29 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+internal static class PackagesConfigDiscovery
+{
+    public static PackagesConfigDiscoveryResult? Discover(string workspacePath, string projectPath, Logger logger)
+    {
+        if (!NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
+        {
+            logger.Log("  No packages.config file found.");
+            return null;
+        }
+
+        var packagesConfigFile = PackagesConfigBuildFile.Open(workspacePath, packagesConfigPath);
+
+        logger.Log($"  Discovered [{packagesConfigFile.RelativePath}] file.");
+
+        var dependencies = BuildFile.GetDependencies(packagesConfigFile)
+            .OrderBy(d => d.Name)
+            .ToImmutableArray();
+
+        return new()
+        {
+            FilePath = packagesConfigFile.RelativePath,
+            Dependencies = dependencies,
+        };
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/PackagesConfigDiscoveryResult.cs

@@ -0,0 +1,10 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public sealed record PackagesConfigDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<Dependency> Dependencies { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/ProjectDiscoveryResult.cs

@@ -0,0 +1,13 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public record ProjectDiscoveryResult : IDiscoveryResultWithDependencies
+{
+    public required string FilePath { get; init; }
+    public required ImmutableArray<Dependency> Dependencies { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<Property> Properties { get; init; } = [];
+    public ImmutableArray<string> TargetFrameworks { get; init; } = [];
+    public ImmutableArray<string> ReferencedProjectPaths { get; init; } = [];
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/SdkProjectDiscovery.cs

@@ -0,0 +1,128 @@
+using System.Collections.Immutable;
+
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Discover;
+
+internal static class SdkProjectDiscovery
+{
+    public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string projectPath, Logger logger)
+    {
+        // Determine which targets and props files contribute to the build.
+        var (buildFiles, projectTargetFrameworks) = await MSBuildHelper.LoadBuildFilesAndTargetFrameworksAsync(repoRootPath, projectPath);
+        var tfms = projectTargetFrameworks.Order().ToImmutableArray();
+
+        // Get all the dependencies which are directly referenced from the project file or indirectly referenced from
+        // targets and props files.
+        var topLevelDependencies = MSBuildHelper.GetTopLevelPackageDependencyInfos(buildFiles);
+
+        var results = ImmutableArray.CreateBuilder<ProjectDiscoveryResult>();
+        if (tfms.Length > 0)
+        {
+            foreach (var buildFile in buildFiles)
+            {
+                // Only include build files that exist beneath the RepoRootPath.
+                if (buildFile.IsOutsideBasePath)
+                {
+                    continue;
+                }
+
+                // The build file dependencies have the correct DependencyType and the TopLevelDependencies have the evaluated version.
+                // Combine them to have the set of dependencies that are directly referenced from the build file.
+                var fileDependencies = BuildFile.GetDependencies(buildFile)
+                    .ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
+                var sdkDependencies = fileDependencies.Values
+                    .Where(d => d.Type == DependencyType.MSBuildSdk)
+                    .ToImmutableArray();
+                var indirectDependencies = topLevelDependencies
+                    .Where(d => !fileDependencies.ContainsKey(d.Name))
+                    .ToImmutableArray();
+                var directDependencies = topLevelDependencies
+                    .Where(d => fileDependencies.ContainsKey(d.Name))
+                    .Select(d =>
+                    {
+                        var dependency = fileDependencies[d.Name];
+                        return d with
+                        {
+                            Type = dependency.Type,
+                            IsDirect = true
+                        };
+                    }).ToImmutableArray();
+
+                if (buildFile.GetFileType() == ProjectBuildFileType.Project)
+                {
+                    // Collect information that is specific to the project file.
+                    var properties = MSBuildHelper.GetProperties(buildFiles).Values
+                        .Where(p => !p.SourceFilePath.StartsWith(".."))
+                        .OrderBy(p => p.Name)
+                        .ToImmutableArray();
+                    var referencedProjectPaths = MSBuildHelper.GetProjectPathsFromProject(projectPath)
+                        .Select(path => Path.GetRelativePath(workspacePath, path))
+                        .OrderBy(p => p)
+                        .ToImmutableArray();
+
+                    // Get the complete set of dependencies including transitive dependencies.
+                    var dependencies = indirectDependencies.Concat(directDependencies).ToImmutableArray();
+                    dependencies = dependencies
+                        .Select(d => d with { TargetFrameworks = tfms })
+                        .ToImmutableArray();
+                    var transitiveDependencies = await GetTransitiveDependencies(repoRootPath, projectPath, tfms, dependencies, logger);
+                    ImmutableArray<Dependency> allDependencies = dependencies.Concat(transitiveDependencies).Concat(sdkDependencies)
+                        .OrderBy(d => d.Name)
+                        .ToImmutableArray();
+
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Properties = properties,
+                        TargetFrameworks = tfms,
+                        ReferencedProjectPaths = referencedProjectPaths,
+                        Dependencies = allDependencies,
+                    });
+                }
+                else
+                {
+                    results.Add(new()
+                    {
+                        FilePath = Path.GetRelativePath(workspacePath, buildFile.Path),
+                        Dependencies = directDependencies.Concat(sdkDependencies)
+                            .OrderBy(d => d.Name)
+                            .ToImmutableArray(),
+                    });
+                }
+            }
+        }
+
+        return results.ToImmutable();
+    }
+
+    private static async Task<ImmutableArray<Dependency>> GetTransitiveDependencies(string repoRootPath, string projectPath, ImmutableArray<string> tfms, ImmutableArray<Dependency> directDependencies, Logger logger)
+    {
+        Dictionary<string, Dependency> transitiveDependencies = new(StringComparer.OrdinalIgnoreCase);
+        foreach (var tfm in tfms)
+        {
+            var tfmDependencies = await MSBuildHelper.GetAllPackageDependenciesAsync(repoRootPath, projectPath, tfm, directDependencies, logger);
+            foreach (var dependency in tfmDependencies.Where(d => d.IsTransitive))
+            {
+                if (!transitiveDependencies.TryGetValue(dependency.Name, out var existingDependency))
+                {
+                    transitiveDependencies[dependency.Name] = dependency;
+                    continue;
+                }
+
+                transitiveDependencies[dependency.Name] = existingDependency with
+                {
+                    // Revisit this logic. We may want to return each dependency instead of merging them.
+                    Version = SemanticVersion.Parse(existingDependency.Version!) > SemanticVersion.Parse(dependency.Version!)
+                        ? existingDependency.Version
+                        : dependency.Version,
+                    TargetFrameworks = existingDependency.TargetFrameworks is not null && dependency.TargetFrameworks is not null
+                        ? existingDependency.TargetFrameworks.Value.AddRange(dependency.TargetFrameworks)
+                        : existingDependency.TargetFrameworks ?? dependency.TargetFrameworks,
+                };
+            }
+        }
+
+        return [.. transitiveDependencies.Values];
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/WorkspaceDiscoveryResult.cs

@@ -0,0 +1,13 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Discover;
+
+public sealed record WorkspaceDiscoveryResult : IDiscoveryResult
+{
+    public required string FilePath { get; init; }
+    public bool IsSuccess { get; init; } = true;
+    public ImmutableArray<ProjectDiscoveryResult> Projects { get; init; }
+    public DirectoryPackagesPropsDiscoveryResult? DirectoryPackagesProps { get; init; }
+    public GlobalJsonDiscoveryResult? GlobalJson { get; init; }
+    public DotNetToolsJsonDiscoveryResult? DotNetToolsJson { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/EvaluationResult.cs

@@ -0,0 +1,8 @@
+namespace NuGetUpdater.Core;
+
+public record EvaluationResult(
+    EvaluationResultType ResultType,
+    string OriginalValue,
+    string EvaluatedValue,
+    string? RootPropertyName,
+    string? ErrorMessage);

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/EvaluationResultType.cs

@@ -0,0 +1,9 @@
+namespace NuGetUpdater.Core;
+
+public enum EvaluationResultType
+{
+    Success,
+    PropertyIgnored,
+    CircularReference,
+    PropertyNotFound,
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/BuildFile.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 
 using DiffPlex;
 using DiffPlex.DiffBuilder;
@@ -12,13 +8,15 @@ namespace NuGetUpdater.Core;
 
 internal abstract class BuildFile
 {
-    public string RepoRootPath { get; }
+    public string BasePath { get; }
     public string Path { get; }
-    public string RepoRelativePath => System.IO.Path.GetRelativePath(RepoRootPath, Path);
+    public string RelativePath => System.IO.Path.GetRelativePath(BasePath, Path);
+    public bool IsOutsideBasePath => RelativePath.StartsWith("..");
+    public bool FailedToParse { get; protected set; }
 
-    public BuildFile(string repoRootPath, string path)
+    public BuildFile(string basePath, string path)
     {
-        RepoRootPath = repoRootPath;
+        BasePath = basePath;
         Path = path;
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/DotNetToolsJsonBuildFile.cs

@@ -1,17 +1,14 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Text.Json.Nodes;
 
 namespace NuGetUpdater.Core;
 
 internal sealed class DotNetToolsJsonBuildFile : JsonBuildFile
 {
-    public static DotNetToolsJsonBuildFile Open(string repoRootPath, string path, Logger logger)
-        => new(repoRootPath, path, File.ReadAllText(path), logger);
+    public static DotNetToolsJsonBuildFile Open(string basePath, string path, Logger logger)
+        => new(basePath, path, File.ReadAllText(path), logger);
 
-    public DotNetToolsJsonBuildFile(string repoRootPath, string path, string contents, Logger logger)
-        : base(repoRootPath, path, contents, logger)
+    public DotNetToolsJsonBuildFile(string basePath, string path, string contents, Logger logger)
+        : base(basePath, path, contents, logger)
     {
     }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/GlobalJsonBuildFile.cs

@@ -1,36 +1,43 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Text.Json.Nodes;
 
 namespace NuGetUpdater.Core;
 
 internal sealed class GlobalJsonBuildFile : JsonBuildFile
 {
-    public static GlobalJsonBuildFile Open(string repoRootPath, string path, Logger logger)
-        => new(repoRootPath, path, File.ReadAllText(path), logger);
+    public static GlobalJsonBuildFile Open(string basePath, string path, Logger logger)
+        => new(basePath, path, File.ReadAllText(path), logger);
 
-    public GlobalJsonBuildFile(string repoRootPath, string path, string contents, Logger logger)
-        : base(repoRootPath, path, contents, logger)
+    public GlobalJsonBuildFile(string basePath, string path, string contents, Logger logger)
+        : base(basePath, path, contents, logger)
     {
     }
 
-    public JsonObject? Sdk
+    public JsonObject? Sdk => Node.Value is JsonObject root ? root["sdk"]?.AsObject() : null;
+
+    public JsonObject? MSBuildSdks => Node.Value is JsonObject root ? root["msbuild-sdks"]?.AsObject() : null;
+
+    public IEnumerable<Dependency> GetDependencies()
     {
-        get
+        List<Dependency> dependencies = [];
+        if (Sdk is not null
+            && Sdk.TryGetPropertyValue("version", out var version))
         {
-            return Node.Value is JsonObject root ? root["sdk"]?.AsObject() : null;
+            dependencies.Add(GetSdkDependency("Microsoft.NET.Sdk", version));
         }
-    }
 
-    public JsonObject? MSBuildSdks
-    {
-        get
+        if (MSBuildSdks is null)
         {
-            return Node.Value is JsonObject root ? root["msbuild-sdks"]?.AsObject() : null;
+            return dependencies;
         }
+
+        var msBuildDependencies = MSBuildSdks
+            .Select(t => GetSdkDependency(t.Key, t.Value));
+        dependencies.AddRange(msBuildDependencies);
+        return dependencies;
     }
 
-    public IEnumerable<Dependency> GetDependencies() => MSBuildSdks?.AsObject().Select(
-        t => new Dependency(t.Key, t.Value?.GetValue<string>() ?? string.Empty, DependencyType.MSBuildSdk)) ?? Enumerable.Empty<Dependency>();
+    private Dependency GetSdkDependency(string name, JsonNode? version)
+    {
+        return new Dependency(name, version?.GetValue<string>(), DependencyType.MSBuildSdk);
+    }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/JsonBuildFile.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 
@@ -40,7 +39,8 @@ internal abstract class JsonBuildFile : BuildFile<string>
             {
                 // We can't police that people have legal JSON files.
                 // If they don't, we just return null.
-                logger.Log($"Failed to parse JSON file: {RepoRelativePath}, got {ex}");
+                logger.Log($"Failed to parse JSON file: {RelativePath}, got {ex}");
+                FailedToParse = true;
                 return null;
             }
         });