fix(issue-6): round-4 fixes + cross-surface coverage (CodeLens, Add-Key, CLI, TUI, sync)

VS Code extension:
- CodeLens for code files now uses the backend scan (cacheService.scanFile)
  instead of client-side regex, so namespace/using segments are no longer
  flagged as keys and value hints appear for any injected localizer (Q, Loc,
  ...), not only L.
- Add-Key dialog gained a per-language value matrix (default marked) and a
  default-empty-value warning; buildAddKeyMessage takes a per-language map.

API (web/VS Code backend):
- ResourcesController.AddKey routes the "default"-keyed value to the suffix-less
  default file regardless of configured DefaultLanguageCode (ResolveForFile).

CLI:
- `lrm add --lang default:value` resolves to the default file via IsDefault, so
  it works when DefaultLanguageCode (e.g. "it") is configured.

TUI:
- AddNewKey writes via MergedLanguageColumns winner so a default-vs-culture
  collision reliably routes the value to the default file.

Sync:
- FileRegenerator creates new language files in the group's own subfolder
  instead of the project root.

Tests:
- New Issue6Scenario fixture project + integration tests (subfolder discovery,
  default-code collision, nested namespace, @Inject localizers, multi-group
  Add-Key).
- CLI language-resolution tests, TUI add-key routing tests, sync
  new-language-in-subfolder + nested-group push/pull round-trip tests, CodeLens
  unit tests, Add-Key message builder tests.

Author: nickprotop

Commands/AddCommand.cs

@@ -164,17 +164,10 @@ private int ExecuteSimpleAdd(AddCommandSettings settings, List<LanguageInfo> lan
                 var code = parts[0].Trim();
                 var value = parts[1];
 
-                // Normalize "default" alias to empty string
-                if (code.Equals("default", StringComparison.OrdinalIgnoreCase))
-                {
-                    code = "";
-                }
-
-                // Validate language code exists
-                var matchingLang = languages.FirstOrDefault(l => l.Code.Equals(code, StringComparison.OrdinalIgnoreCase));
+                var matchingLang = ResolveLanguageForCode(languages, code);
                 if (matchingLang == null)
                 {
-                    var availableCodes = string.Join(", ", languages.Select(l => l.Code));
+                    var availableCodes = string.Join(", ", languages.Select(l => string.IsNullOrEmpty(l.Code) ? "default" : l.Code));
                     AnsiConsole.MarkupLine($"[red]✗ Unknown language code: '{code}'[/]");
                     AnsiConsole.MarkupLine($"[yellow]Available languages: {availableCodes}[/]");
                     return 1;
@@ -235,6 +228,22 @@ private int ExecuteSimpleAdd(AddCommandSettings settings, List<LanguageInfo> lan
         });
     }
 
+    /// <summary>
+    /// Resolves a <c>--lang code:value</c> code to a discovered language. The "default"
+    /// alias maps to the default file regardless of its actual code: that code may be
+    /// blank, or a configured DefaultLanguageCode such as "it", so resolving by IsDefault
+    /// (rather than assuming "") keeps <c>--lang default:value</c> working in both cases
+    /// (issue #6). Returns null when no language matches.
+    /// </summary>
+    internal static LanguageInfo? ResolveLanguageForCode(List<LanguageInfo> languages, string code)
+    {
+        if (code.Equals("default", StringComparison.OrdinalIgnoreCase))
+        {
+            return languages.FirstOrDefault(l => l.IsDefault);
+        }
+        return languages.FirstOrDefault(l => l.Code.Equals(code, StringComparison.OrdinalIgnoreCase));
+    }
+
     private int ExecutePluralAdd(AddCommandSettings settings, List<LanguageInfo> languages, List<ResourceFile> resourceFiles, string resourcePath)
     {
         // Collect plural forms for each language

Controllers/ResourcesController.cs

@@ -324,12 +324,10 @@ public ActionResult<OperationResponse> AddKey([FromBody] AddKeyRequest request)
             // Add the key to all resource files in this group
             foreach (var resourceFile in resourceFiles)
             {
-                var langCode = resourceFile.Language.Code ?? "default";
-
                 if (request.IsPlural && request.PluralValues != null)
                 {
                     // Add plural key
-                    var pluralForms = request.PluralValues.GetValueOrDefault(langCode)
+                    var pluralForms = ResolveForFile(request.PluralValues, resourceFile.Language)
                         ?? new Dictionary<string, string> { ["other"] = "" };
 
                     resourceFile.Entries.Add(new ResourceEntry
@@ -344,7 +342,7 @@ public ActionResult<OperationResponse> AddKey([FromBody] AddKeyRequest request)
                 else
                 {
                     // Add simple key
-                    var value = request.Values?.GetValueOrDefault(langCode) ?? string.Empty;
+                    var value = ResolveForFile(request.Values, resourceFile.Language) ?? string.Empty;
 
                     resourceFile.Entries.Add(new ResourceEntry
                     {
@@ -369,6 +367,27 @@ public ActionResult<OperationResponse> AddKey([FromBody] AddKeyRequest request)
         }
     }
 
+    /// <summary>
+    /// Resolves the per-language value to write into a given file from a
+    /// language-keyed payload. The Add-Key webview sends the default value under
+    /// the "default" key, while explicit cultures are keyed by their code. The
+    /// default file may have a blank code or an explicit DefaultLanguageCode
+    /// (e.g. "it"), so we try, in order: the file's effective display code, its
+    /// raw code, and — for the default file only — the literal "default" key.
+    /// </summary>
+    private static TValue? ResolveForFile<TValue>(
+        Dictionary<string, TValue>? values,
+        Core.Models.LanguageInfo language)
+    {
+        if (values == null) return default;
+
+        if (values.TryGetValue(language.GetDisplayCode(), out var byDisplay)) return byDisplay;
+        if (!string.IsNullOrEmpty(language.Code) && values.TryGetValue(language.Code, out var byCode)) return byCode;
+        if (language.IsDefault && values.TryGetValue("default", out var byDefault)) return byDefault;
+
+        return default;
+    }
+
     /// <summary>
     /// Update an existing key within a specific resource group (supports occurrence
     /// parameter for duplicates). When the directory has exactly one group,

LocalizationManager.Core/Cloud/FileRegenerator.cs

@@ -45,10 +45,21 @@ public async Task<RegenerationResult> RegenerateFilesAsync(
 
         // Lookup for existing language files keyed by (BaseName, Code).
         var existingLangFiles = new Dictionary<(string BaseName, string Code), LanguageInfo>();
+        // Directory each resource group lives in, so a NEW language file for that group is
+        // created alongside its siblings (e.g. Resources/Components/Account/Pages/) instead
+        // of at the project root (issue #6: subfolder groups).
+        var groupDirectories = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         foreach (var lang in existingLanguages)
         {
             var key = (lang.BaseName ?? string.Empty, lang.Code);
             existingLangFiles[key] = lang;
+
+            var bn = lang.BaseName ?? string.Empty;
+            if (!groupDirectories.ContainsKey(bn) && !string.IsNullOrEmpty(lang.FilePath))
+            {
+                var dir = Path.GetDirectoryName(lang.FilePath);
+                if (!string.IsNullOrEmpty(dir)) groupDirectories[bn] = dir;
+            }
         }
 
         // Check if the backend uses explicit language codes for the default language
@@ -93,13 +104,15 @@ await UpdateExistingFileAsync(
                 }
                 else
                 {
-                    // Create new language file
+                    // Create new language file alongside the group's existing files.
+                    groupDirectories.TryGetValue(baseName, out var groupDir);
                     await CreateNewLanguageFileAsync(
                         baseName,
                         resolvedLang,
                         entries,
                         tempDir,
                         result,
+                        groupDir,
                         cancellationToken);
                 }
             }
@@ -232,10 +245,12 @@ private async Task CreateNewLanguageFileAsync(
         List<MergedEntry> entries,
         string tempDir,
         RegenerationResult result,
+        string? groupDirectory,
         CancellationToken cancellationToken)
     {
-        // Determine file path for new language, honoring the resource group's base name.
-        var filePath = GetNewLanguageFilePath(baseName, lang);
+        // Determine file path for new language, honoring the resource group's base name
+        // and the directory the group lives in (so subfolder groups stay in their folder).
+        var filePath = GetNewLanguageFilePath(baseName, lang, groupDirectory);
 
         // Create language info for new file
         var languageInfo = new LanguageInfo
@@ -357,12 +372,16 @@ private string GetRelativeFilePath(string? filePath, string baseDirectory)
     /// and the resource group's base name. Empty <paramref name="baseName"/>
     /// falls back to the historical default naming.
     /// </summary>
-    private string GetNewLanguageFilePath(string baseName, string lang)
+    private string GetNewLanguageFilePath(string baseName, string lang, string? groupDirectory = null)
     {
         // Get path convention from backend
         var backendName = _backend.Name.ToLowerInvariant();
         var isDefaultLang = string.IsNullOrEmpty(lang);
 
+        // Place the new file in the group's own directory when known (preserves subfolder
+        // layout, e.g. Resources/Components/Account/Pages/), else at the project root.
+        var baseDir = string.IsNullOrEmpty(groupDirectory) ? _projectDirectory : groupDirectory;
+
         // For backends where the file name embeds the base name (resx, json,
         // xliff), use the base name as the file root; otherwise fall back to
         // the conventional defaults.
@@ -374,29 +393,29 @@ private string GetNewLanguageFilePath(string baseName, string lang)
         return backendName switch
         {
             "resx" => isDefaultLang
-                ? Path.Combine(_projectDirectory, $"{resxRoot}.resx")
-                : Path.Combine(_projectDirectory, $"{resxRoot}.{lang}.resx"),
+                ? Path.Combine(baseDir, $"{resxRoot}.resx")
+                : Path.Combine(baseDir, $"{resxRoot}.{lang}.resx"),
             "json" or "jsonlocalization" => isDefaultLang
-                ? Path.Combine(_projectDirectory, $"{jsonRoot}.json")
-                : Path.Combine(_projectDirectory, $"{jsonRoot}.{lang}.json"),
+                ? Path.Combine(baseDir, $"{jsonRoot}.json")
+                : Path.Combine(baseDir, $"{jsonRoot}.{lang}.json"),
             "android" => isDefaultLang
-                ? Path.Combine(_projectDirectory, "values", "strings.xml")
-                : Path.Combine(_projectDirectory, $"values-{lang}", "strings.xml"),
+                ? Path.Combine(baseDir, "values", "strings.xml")
+                : Path.Combine(baseDir, $"values-{lang}", "strings.xml"),
             "ios" or "strings" => isDefaultLang
-                ? Path.Combine(_projectDirectory, "en.lproj", "Localizable.strings")
-                : Path.Combine(_projectDirectory, $"{lang}.lproj", "Localizable.strings"),
+                ? Path.Combine(baseDir, "en.lproj", "Localizable.strings")
+                : Path.Combine(baseDir, $"{lang}.lproj", "Localizable.strings"),
             "i18next" => isDefaultLang
-                ? Path.Combine(_projectDirectory, "en.json")
-                : Path.Combine(_projectDirectory, $"{lang}.json"),
+                ? Path.Combine(baseDir, "en.json")
+                : Path.Combine(baseDir, $"{lang}.json"),
             "xliff" => isDefaultLang
-                ? Path.Combine(_projectDirectory, $"{xlfRoot}.xlf")
-                : Path.Combine(_projectDirectory, $"{xlfRoot}.{lang}.xlf"),
+                ? Path.Combine(baseDir, $"{xlfRoot}.xlf")
+                : Path.Combine(baseDir, $"{xlfRoot}.{lang}.xlf"),
             "po" or "gettext" => isDefaultLang
-                ? Path.Combine(_projectDirectory, $"{poRoot}.pot")
-                : Path.Combine(_projectDirectory, $"{lang}.po"),
+                ? Path.Combine(baseDir, $"{poRoot}.pot")
+                : Path.Combine(baseDir, $"{lang}.po"),
             _ => isDefaultLang
-                ? Path.Combine(_projectDirectory, $"strings.{backendName}")
-                : Path.Combine(_projectDirectory, $"strings.{lang}.{backendName}")
+                ? Path.Combine(baseDir, $"strings.{backendName}")
+                : Path.Combine(baseDir, $"strings.{lang}.{backendName}")
         };
     }
 

LocalizationManager.Tests/IntegrationTests/AddCommandLanguageResolutionTests.cs

@@ -0,0 +1,95 @@
+// Copyright (c) 2025 Nikolaos Protopapas
+// Licensed under the MIT License
+
+using LocalizationManager.Commands;
+using LocalizationManager.Core.Backends.Resx;
+using LocalizationManager.Core.Models;
+using Xunit;
+
+namespace LocalizationManager.Tests.IntegrationTests;
+
+/// <summary>
+/// Tests for the CLI `lrm add --lang code:value` language resolution (issue #6).
+/// The "default" alias must target the suffix-less default file whether its code is
+/// blank (no DefaultLanguageCode configured) or a configured code such as "it".
+/// Driven from real discovery over a temp resource directory.
+/// </summary>
+public class AddCommandLanguageResolutionTests : IDisposable
+{
+    private readonly string _dir;
+
+    public AddCommandLanguageResolutionTests()
+    {
+        _dir = Path.Combine(Path.GetTempPath(), $"LrmAddLang_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(_dir);
+    }
+
+    public void Dispose()
+    {
+        if (Directory.Exists(_dir)) Directory.Delete(_dir, true);
+    }
+
+    private void WriteResx(string fileName, params (string Key, string Value)[] entries)
+    {
+        var body = string.Join("\n", entries.Select(e =>
+            $"  <data name=\"{e.Key}\"><value>{e.Value}</value></data>"));
+        File.WriteAllText(Path.Combine(_dir, fileName),
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<root>\n" +
+            "  <resheader name=\"resmimetype\"><value>text/microsoft-resx</value></resheader>\n" +
+            body + "\n</root>\n");
+    }
+
+    [Fact]
+    public void Default_NoConfiguredCode_ResolvesToBlankCodeDefaultFile()
+    {
+        WriteResx("Res.resx", ("Hi", "Hi"));
+        WriteResx("Res.it.resx", ("Hi", "Ciao"));
+        var languages = new ResxResourceDiscovery().DiscoverLanguages(_dir);
+
+        var match = AddCommand.ResolveLanguageForCode(languages, "default");
+
+        Assert.NotNull(match);
+        Assert.True(match!.IsDefault);
+        Assert.Equal("", match.Code);
+    }
+
+    [Fact]
+    public void Default_ConfiguredItCode_ResolvesToDefaultFileLabeledIt()
+    {
+        // DefaultLanguageCode = "it": the default file is labeled "it" and there is also
+        // an explicit Res.it.resx. "default" must still resolve to the default file.
+        WriteResx("Res.resx", ("Hi", "Ciao"));
+        WriteResx("Res.it.resx", ("Hi", "CiaoCulture"));
+        var languages = new ResxResourceDiscovery("it").DiscoverLanguages(_dir);
+
+        var match = AddCommand.ResolveLanguageForCode(languages, "default");
+
+        Assert.NotNull(match);
+        Assert.True(match!.IsDefault, "'default' must map to the default file");
+        Assert.EndsWith("Res.resx", match.FilePath);
+        Assert.DoesNotContain(".it.resx", match.FilePath);
+    }
+
+    [Fact]
+    public void ExplicitCultureCode_ResolvesToThatCultureFile()
+    {
+        WriteResx("Res.resx", ("Hi", "Ciao"));
+        WriteResx("Res.el.resx", ("Hi", "Γεια"));
+        var languages = new ResxResourceDiscovery("it").DiscoverLanguages(_dir);
+
+        var match = AddCommand.ResolveLanguageForCode(languages, "el");
+
+        Assert.NotNull(match);
+        Assert.False(match!.IsDefault);
+        Assert.Equal("el", match.Code);
+    }
+
+    [Fact]
+    public void UnknownCode_ReturnsNull()
+    {
+        WriteResx("Res.resx", ("Hi", "Ciao"));
+        var languages = new ResxResourceDiscovery("it").DiscoverLanguages(_dir);
+
+        Assert.Null(AddCommand.ResolveLanguageForCode(languages, "zz"));
+    }
+}