Fix default-language, recursive discovery, multi-group scanning and VS Code reference paths

Addresses four issues reported on #6 after the multi-base resource group fix:

- RESX/JSON discovery now honor defaultLanguageCode for the suffix-less
  default file instead of reporting an empty code, so every client labels
  it as the real language.
- RESX/JSON discovery recurse into subfolders (excluding .lrm/.backups/bin/
  obj/.git/node_modules) and group subfolder-aware, so nested resource
  files are discovered (and uploaded on cloud push).
- CodeScanner unions keys across all default files, fixing false
  missing-key diagnostics in multi-group projects.
- VS Code extension: reference links use data attributes + Uri.file so
  Windows paths are no longer corrupted, and the dashboard/status bar show
  the configured default language instead of hardcoded "English (Default)".

Test fixtures moved into FlatResx/ and JsonResourcesI18next/ so recursive
discovery no longer sweeps unrelated nested fixtures into flat-layout tests.

Author: nickprotop

LocalizationManager.Core/Backends/Json/JsonResourceBackend.cs

@@ -99,8 +99,8 @@ public bool CanHandle(string path)
         if (!Directory.Exists(path))
             return false;
 
-        // Check for JSON files, excluding lrm*.json config files
-        return Directory.GetFiles(path, "*.json", SearchOption.TopDirectoryOnly)
+        // Check for JSON files (including nested subfolders), excluding lrm*.json config files
+        return Directory.EnumerateFiles(path, "*.json", SearchOption.AllDirectories)
             .Any(f => !Path.GetFileName(f).StartsWith("lrm", StringComparison.OrdinalIgnoreCase));
     }
 }

LocalizationManager.Core/Backends/Json/JsonResourceDiscovery.cs

@@ -52,8 +52,11 @@ public List<LanguageInfo> DiscoverLanguages(string searchPath)
         var config = _config ?? LoadConfigFromPath(searchPath);
         var defaultLanguageCode = LoadDefaultLanguageFromPath(searchPath);
 
-        var jsonFiles = Directory.GetFiles(searchPath, "*.json", SearchOption.TopDirectoryOnly)
+        // Recurse so JSON files in nested subfolders of the resource path are discovered.
+        // Skip config files (lrm*.json) and well-known non-source directories.
+        var jsonFiles = Directory.GetFiles(searchPath, "*.json", SearchOption.AllDirectories)
             .Where(f => !Path.GetFileName(f).StartsWith("lrm", StringComparison.OrdinalIgnoreCase))
+            .Where(f => !IsInExcludedDirectory(f, searchPath))
             .ToList();
 
         if (!jsonFiles.Any())
@@ -135,15 +138,23 @@ private List<LanguageInfo> DiscoverStandardFiles(List<string> jsonFiles, string?
                 // 1. It has no culture code (e.g., strings.json), OR
                 // 2. Its culture code matches the defaultLanguageCode from lrm.json
                 var cultureCode = file!.Value.CultureCode;
-                var isDefault = string.IsNullOrEmpty(cultureCode) ||
+                var isSuffixless = string.IsNullOrEmpty(cultureCode);
+                var isDefault = isSuffixless ||
                                (!string.IsNullOrEmpty(configDefaultLanguage) &&
                                 cultureCode.Equals(configDefaultLanguage, StringComparison.OrdinalIgnoreCase));
+
+                // A suffix-less default file (e.g. strings.json) adopts the configured
+                // default language code so clients label it as the real language rather
+                // than as an unnamed default.
+                var effectiveCode = isSuffixless && !string.IsNullOrEmpty(configDefaultLanguage)
+                    ? configDefaultLanguage!
+                    : cultureCode;
                 var displayName = isDefault ? "Default" : GetCultureDisplayName(cultureCode);
 
                 result.Add(new LanguageInfo
                 {
                     BaseName = file.Value.BaseName,
-                    Code = cultureCode,
+                    Code = effectiveCode,
                     Name = displayName,
                     IsDefault = isDefault,
                     FilePath = file.Value.FilePath
@@ -373,6 +384,23 @@ private string GetCultureDisplayName(string code)
         }
     }
 
+    /// <summary>
+    /// Directories that should never be treated as resource sources when recursing.
+    /// </summary>
+    private static readonly string[] ExcludedDirectories =
+        { ".lrm", ".backups", "bin", "obj", ".git", "node_modules" };
+
+    /// <summary>
+    /// Returns true if the file lives under an excluded directory relative to the search root.
+    /// </summary>
+    private static bool IsInExcludedDirectory(string filePath, string searchPath)
+    {
+        var relative = Path.GetRelativePath(searchPath, filePath);
+        var segments = relative.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        return segments.Take(segments.Length - 1)
+            .Any(seg => ExcludedDirectories.Contains(seg, StringComparer.OrdinalIgnoreCase));
+    }
+
     /// <inheritdoc />
     public Task<List<LanguageInfo>> DiscoverLanguagesAsync(string searchPath, CancellationToken ct = default)
         => Task.FromResult(DiscoverLanguages(searchPath));

LocalizationManager.Core/Backends/ResourceBackendFactory.cs

@@ -59,7 +59,7 @@ public IResourceBackend GetBackend(string name, ConfigurationModel? config)
 
         return lowerName switch
         {
-            "resx" => new ResxResourceBackend(),
+            "resx" => new ResxResourceBackend(config?.DefaultLanguageCode),
             "json" or "jsonlocalization" => new JsonResourceBackend(config?.Json),
             "i18next" => new JsonResourceBackend(config?.Json ?? new Configuration.JsonFormatConfiguration { I18nextCompatible = true }),
             "android" => new AndroidResourceBackend(

LocalizationManager.Core/Backends/Resx/ResxResourceBackend.cs

@@ -47,9 +47,16 @@ public class ResxResourceBackend : IResourceBackend
     /// <inheritdoc />
     public IResourceValidator Validator { get; }
 
-    public ResxResourceBackend()
+    /// <summary>
+    /// Creates a RESX backend.
+    /// </summary>
+    /// <param name="defaultLanguageCode">
+    /// The default/source language code from configuration (e.g. "it"). Used to label the
+    /// suffix-less default file with the real language code instead of an empty string.
+    /// </param>
+    public ResxResourceBackend(string? defaultLanguageCode = null)
     {
-        Discovery = new ResxResourceDiscovery();
+        Discovery = new ResxResourceDiscovery(defaultLanguageCode);
         Reader = new ResxResourceReader();
         Writer = new ResxResourceWriter();
         Validator = new ResxResourceValidator();
@@ -61,6 +68,7 @@ public bool CanHandle(string path)
         if (!Directory.Exists(path))
             return false;
 
-        return Directory.GetFiles(path, "*.resx", SearchOption.TopDirectoryOnly).Any();
+        // Recurse: a project may keep its .resx files only in subfolders.
+        return Directory.EnumerateFiles(path, "*.resx", SearchOption.AllDirectories).Any();
     }
 }

LocalizationManager.Core/Backends/Resx/ResxResourceDiscovery.cs

@@ -31,6 +31,22 @@ namespace LocalizationManager.Core.Backends.Resx;
 /// </summary>
 public class ResxResourceDiscovery : IResourceDiscovery
 {
+    private readonly string? _defaultLanguageCode;
+
+    /// <summary>
+    /// Creates a RESX discovery instance.
+    /// </summary>
+    /// <param name="defaultLanguageCode">
+    /// The default/source language code from configuration (e.g. "it"). When set, the
+    /// suffix-less default file (e.g. CustomerResources.resx) is reported with this code
+    /// instead of an empty string, so every client labels it as the real language rather
+    /// than guessing "English". When null, the default file keeps an empty code.
+    /// </param>
+    public ResxResourceDiscovery(string? defaultLanguageCode = null)
+    {
+        _defaultLanguageCode = string.IsNullOrWhiteSpace(defaultLanguageCode) ? null : defaultLanguageCode;
+    }
+
     /// <inheritdoc />
     public List<LanguageInfo> DiscoverLanguages(string searchPath)
     {
@@ -41,24 +57,29 @@ public List<LanguageInfo> DiscoverLanguages(string searchPath)
 
         var languages = new List<LanguageInfo>();
 
-        // Find all .resx files (exclude .Designer.cs files)
-        var resxFiles = Directory.GetFiles(searchPath, "*.resx", SearchOption.TopDirectoryOnly)
+        // Find all .resx files recursively (exclude .Designer.cs files and well-known
+        // non-source directories like backups/build output). Files may live in nested
+        // subfolders of the resource path (e.g. Resources/Components/.../Login.it.resx).
+        var resxFiles = Directory.GetFiles(searchPath, "*.resx", SearchOption.AllDirectories)
             .Where(f => !f.EndsWith(".Designer.cs", StringComparison.OrdinalIgnoreCase))
+            .Where(f => !IsInExcludedDirectory(f, searchPath))
             .ToList();
 
         if (!resxFiles.Any())
         {
             return languages;
         }
 
-        // Group by base name (e.g., "SharedResource" from "SharedResource.resx" and "SharedResource.el.resx")
+        // Group by directory + base name so unrelated files that share a base name in
+        // different subfolders (e.g. Customers/Resources.resx and Glass/Resources.resx)
+        // are kept as separate resource groups rather than merged.
         var groups = resxFiles
-            .GroupBy(f => GetBaseName(f))
+            .GroupBy(f => GetGroupKey(f))
             .ToList();
 
         foreach (var group in groups)
         {
-            var baseName = group.Key;
+            var baseName = GetBaseName(group.First());
 
             foreach (var file in group)
             {
@@ -67,12 +88,13 @@ public List<LanguageInfo> DiscoverLanguages(string searchPath)
 
                 if (parts.Length == 1)
                 {
-                    // Default language (e.g., SharedResource.resx)
+                    // Default language (e.g., SharedResource.resx). Adopt the configured
+                    // default language code when available; otherwise leave it blank.
                     languages.Add(new LanguageInfo
                     {
                         BaseName = baseName,
-                        Code = "",
-                        Name = "Default",
+                        Code = _defaultLanguageCode ?? "",
+                        Name = _defaultLanguageCode != null ? GetCultureName(_defaultLanguageCode) : "Default",
                         IsDefault = true,
                         FilePath = file
                     });
@@ -116,6 +138,35 @@ private static string GetBaseName(string filePath)
         return fileName.Split('.')[0];
     }
 
+    /// <summary>
+    /// Builds a grouping key from the containing directory and base name, so that files
+    /// sharing a base name in different subfolders form separate resource groups.
+    /// </summary>
+    private static string GetGroupKey(string filePath)
+    {
+        var directory = Path.GetDirectoryName(filePath) ?? string.Empty;
+        return $"{directory}{Path.DirectorySeparatorChar}{GetBaseName(filePath)}";
+    }
+
+    /// <summary>
+    /// Directories that should never be treated as resource sources when recursing
+    /// (backups, build output, VCS and package directories).
+    /// </summary>
+    private static readonly string[] ExcludedDirectories =
+        { ".lrm", ".backups", "bin", "obj", ".git", "node_modules" };
+
+    /// <summary>
+    /// Returns true if the file lives under an excluded directory relative to the search root.
+    /// </summary>
+    private static bool IsInExcludedDirectory(string filePath, string searchPath)
+    {
+        var relative = Path.GetRelativePath(searchPath, filePath);
+        var segments = relative.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+        // All segments except the final file name are directory names.
+        return segments.Take(segments.Length - 1)
+            .Any(seg => ExcludedDirectories.Contains(seg, StringComparer.OrdinalIgnoreCase));
+    }
+
     /// <summary>
     /// Gets the display name for a culture code using .NET CultureInfo.
     /// </summary>

LocalizationManager.Core/Scanning/CodeScanner.cs

@@ -394,13 +394,19 @@ private List<KeyReference> ScanFiles(
 
     private HashSet<string> GetAllResourceKeys(List<ResourceFile> resourceFiles)
     {
-        // Get keys from default language file
-        var defaultFile = resourceFiles.FirstOrDefault(f => f.Language.IsDefault);
-
-        if (defaultFile == null)
-            return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-
-        return new HashSet<string>(defaultFile.Entries.Select(e => e.Key), StringComparer.OrdinalIgnoreCase);
+        // Union the keys from every default language file. In multi-group projects
+        // (e.g. CustomerResources, GlassResources, SharedResources) each base resource
+        // has its own default file, so taking only the first one would flag keys defined
+        // in the other groups as "missing" even though they exist.
+        var defaultFiles = resourceFiles.Where(f => f.Language.IsDefault).ToList();
+
+        // Fall back to all files if none are explicitly marked default (defensive).
+        if (defaultFiles.Count == 0)
+            defaultFiles = resourceFiles;
+
+        return new HashSet<string>(
+            defaultFiles.SelectMany(f => f.Entries.Select(e => e.Key)),
+            StringComparer.OrdinalIgnoreCase);
     }
 
     private List<string> GetLanguagesForKey(List<ResourceFile> resourceFiles, string key)

LocalizationManager.Tests/IntegrationTests/ScanCommandIntegrationTests.cs

@@ -32,7 +32,7 @@ public ScanCommandIntegrationTests()
 
         // Copy TestResource.resx to temp directory
         var testDataPath = Path.Combine(Directory.GetCurrentDirectory(), "TestData");
-        var sourceResxPath = Path.Combine(testDataPath, "TestResource.resx");
+        var sourceResxPath = Path.Combine(testDataPath, "FlatResx", "TestResource.resx");
 
         if (File.Exists(sourceResxPath))
         {

LocalizationManager.Tests/IntegrationTests/ViewCommandIntegrationTests.cs

@@ -18,7 +18,7 @@ public class ViewCommandIntegrationTests
     public ViewCommandIntegrationTests()
     {
         // Use persistent TestData folder
-        _testDirectory = Path.Combine(AppContext.BaseDirectory, "TestData");
+        _testDirectory = Path.Combine(AppContext.BaseDirectory, "TestData", "FlatResx");
 
         // Using _reader and _writer initialized above
         // Using _discovery initialized above