up

src/Scanner/__Libraries/StellaOps.Scanner.Analyzers.Lang.DotNet/Internal/DotNetEntrypointResolver.cs

@@ -45,8 +45,10 @@ public static class DotNetEntrypointResolver
                     continue;
                 }
 
+                var name = GetEntrypointName(depsPath);
+
                 DotNetRuntimeConfig? runtimeConfig = null;
-                var runtimeConfigPath = Path.ChangeExtension(depsPath, ".runtimeconfig.json");
+                var runtimeConfigPath = GetRuntimeConfigPath(depsPath, name);
                 string? relativeRuntimeConfig = null;
 
                 if (!string.IsNullOrEmpty(runtimeConfigPath) && File.Exists(runtimeConfigPath))
@@ -59,7 +61,6 @@ public static class DotNetEntrypointResolver
                 var rids = CollectRuntimeIdentifiers(depsFile, runtimeConfig);
                 var publishKind = DeterminePublishKind(depsFile);
 
-                var name = GetEntrypointName(depsPath);
                 var id = BuildDeterministicId(name, tfms, rids, publishKind);
 
                 results.Add(new DotNetEntrypoint(
@@ -101,6 +102,19 @@ public static class DotNetEntrypointResolver
         return stem;
     }
 
+    private static string GetRuntimeConfigPath(string depsPath, string entrypointName)
+    {
+        var directory = Path.GetDirectoryName(depsPath);
+        var fileName = $"{entrypointName}.runtimeconfig.json";
+
+        if (string.IsNullOrWhiteSpace(directory))
+        {
+            return fileName;
+        }
+
+        return Path.Combine(directory, fileName);
+    }
+
     private static IReadOnlyCollection<string> CollectTargetFrameworks(DotNetDepsFile depsFile, DotNetRuntimeConfig? runtimeConfig)
     {
         var tfms = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
@@ -109,7 +123,11 @@ public static class DotNetEntrypointResolver
         {
             foreach (var tfm in library.TargetFrameworks)
             {
-                tfms.Add(tfm);
+                var normalized = NormalizeTargetFrameworkMoniker(tfm);
+                if (!string.IsNullOrWhiteSpace(normalized))
+                {
+                    tfms.Add(normalized);
+                }
             }
         }
 
@@ -129,6 +147,83 @@ public static class DotNetEntrypointResolver
         return tfms;
     }
 
+    private static string? NormalizeTargetFrameworkMoniker(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        var trimmed = value.Trim();
+
+        if (TryNormalizeFrameworkMoniker(trimmed, ".NETCoreApp,Version=v", "net", out var normalized))
+        {
+            return normalized;
+        }
+
+        if (TryNormalizeFrameworkMoniker(trimmed, ".NETStandard,Version=v", "netstandard", out normalized))
+        {
+            return normalized;
+        }
+
+        if (TryNormalizeFrameworkMoniker(trimmed, ".NETFramework,Version=v", "net", out normalized))
+        {
+            return NormalizeNetFrameworkTfm(normalized!);
+        }
+
+        return trimmed;
+    }
+
+    private static bool TryNormalizeFrameworkMoniker(string value, string prefix, string replacement, out string? normalized)
+    {
+        normalized = null;
+
+        if (!value.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var versionPart = value[prefix.Length..];
+        if (string.IsNullOrWhiteSpace(versionPart))
+        {
+            return false;
+        }
+
+        versionPart = versionPart.Trim();
+        if (!Version.TryParse(versionPart, out var version))
+        {
+            return false;
+        }
+
+        normalized = $"{replacement}{version.Major}.{version.Minor}";
+        return true;
+    }
+
+    private static string NormalizeNetFrameworkTfm(string value)
+    {
+        if (!value.StartsWith("net", StringComparison.OrdinalIgnoreCase))
+        {
+            return value;
+        }
+
+        var versionPart = value[3..];
+        if (!Version.TryParse(versionPart, out var version))
+        {
+            return value.Replace(".", string.Empty, StringComparison.Ordinal);
+        }
+
+        var major = Math.Max(version.Major, 0);
+        var minor = Math.Max(version.Minor, 0);
+        var build = version.Build;
+
+        if (build > 0)
+        {
+            return $"net{major}{minor}{build}";
+        }
+
+        return $"net{major}{minor}";
+    }
+
     private static IReadOnlyCollection<string> CollectRuntimeIdentifiers(DotNetDepsFile depsFile, DotNetRuntimeConfig? runtimeConfig)
     {
         var rids = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);