Improve PO file format preservation

- Preserve fuzzy flags (#, fuzzy, c-format, etc.) during read-write cycles
- Preserve obsolete entries (#~ prefixed entries) instead of skipping them
- Fix UTF-8 BOM issue: write PO files without BOM (per gettext standard)
- Fix extra newlines in header: trim trailing newlines when building header
- Correctly prefix all obsolete entry lines with #~ including flags
- Add Flags and IsObsolete properties to ResourceEntry model
- Update tests for new preservation behavior

Author: nickprotop

Commands/TranslateCommand.cs

@@ -547,6 +547,7 @@ private async Task TranslateKeysAsync(
                     }
 
                     translated++;
+                    targetFile.IsModified = true;  // Mark file as modified
                 }
                 catch (TranslationException ex)
                 {
@@ -558,16 +559,16 @@ private async Task TranslateKeysAsync(
                 }
             }
 
-            // Create backup before saving
-            if (!settings.DryRun && !settings.NoBackup)
+            // Create backup before saving (only if file was modified)
+            if (!settings.DryRun && !settings.NoBackup && targetFile.IsModified)
             {
                 var backupManager = new BackupVersionManager(10);
                 var basePath = System.IO.Path.GetDirectoryName(targetLanguageInfo.FilePath) ?? Environment.CurrentDirectory;
                 await backupManager.CreateBackupAsync(targetLanguageInfo.FilePath, "translate", basePath);
             }
 
-            // Save the updated resource file
-            if (!settings.DryRun)
+            // Save the updated resource file (only if modified)
+            if (!settings.DryRun && targetFile.IsModified)
             {
                 settings.WriteResourceFile(targetFile);
             }

Commands/UpdateCommand.cs

@@ -364,6 +364,7 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
                         }
                         // Update Value to match 'other' form
                         entry.Value = entry.PluralForms.GetValueOrDefault("other") ?? entry.PluralForms.Values.FirstOrDefault();
+                        rf.IsModified = true;  // Mark file as modified
                         updatedCount++;
                     }
                 }
@@ -380,6 +381,7 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
                         if (entry != null)
                         {
                             entry.Value = kvp.Value;
+                            rf.IsModified = true;  // Mark file as modified
                             updatedCount++;
                         }
                     }
@@ -395,12 +397,13 @@ public override int Execute(CommandContext context, Settings settings, Cancellat
                     if (entry != null)
                     {
                         entry.Comment = settings.Comment;
+                        rf.IsModified = true;  // Mark file as modified
                     }
                 }
             }
 
-            // Save changes
-            foreach (var rf in resourceFiles)
+            // Save changes (only modified files)
+            foreach (var rf in resourceFiles.Where(f => f.IsModified))
             {
                 settings.WriteResourceFile(rf);
             }

LocalizationManager.Core/Backends/Po/PoEntry.cs

@@ -35,6 +35,12 @@ internal class PoEntry
     /// </summary>
     public Dictionary<int, string>? MsgStrPlural { get; set; }
 
+    /// <summary>
+    /// Original raw msgstr lines as they appeared in the PO file.
+    /// Used to preserve formatting when writing back unchanged translations.
+    /// </summary>
+    public List<string>? OriginalMsgStrLines { get; set; }
+
     /// <summary>
     /// Translator comment (# comment).
     /// </summary>

LocalizationManager.Core/Backends/Po/PoResourceReader.cs

@@ -68,20 +68,19 @@ private async Task<ResourceFile> ReadAsyncCore(TextReader reader, LanguageInfo m
     {
         var entries = new List<ResourceEntry>();
         PoHeader? header = null;
+        string? originalHeader = null;
         var poEntries = await ParseEntriesAsync(reader, ct);
 
         foreach (var poEntry in poEntries)
         {
             ct.ThrowIfCancellationRequested();
 
-            // Skip obsolete entries
-            if (poEntry.IsObsolete)
-                continue;
-
             // Parse header entry
             if (poEntry.IsHeader)
             {
                 header = PoHeader.Parse(poEntry.MsgStr ?? "");
+                // Capture original header for preservation
+                originalHeader = BuildOriginalHeader(poEntry);
                 continue;
             }
 
@@ -93,7 +92,8 @@ private async Task<ResourceFile> ReadAsyncCore(TextReader reader, LanguageInfo m
         return new ResourceFile
         {
             Language = metadata,
-            Entries = entries
+            Entries = entries,
+            OriginalHeader = originalHeader
         };
     }
 
@@ -174,6 +174,9 @@ private async Task<List<PoEntry>> ParseEntriesAsync(TextReader reader, Cancellat
             {
                 currentEntry.MsgStr = UnescapeString(match.Groups[1].Value);
                 currentField = PoField.MsgStr;
+
+                // Capture original formatting
+                currentEntry.OriginalMsgStrLines = new List<string> { line.Trim() };
                 continue;
             }
 
@@ -185,6 +188,10 @@ private async Task<List<PoEntry>> ParseEntriesAsync(TextReader reader, Cancellat
                 currentEntry.MsgStrPlural ??= new Dictionary<int, string>();
                 currentEntry.MsgStrPlural[index] = UnescapeString(match.Groups[2].Value);
                 currentField = PoField.MsgStrPlural;
+
+                // Capture original formatting (for plural forms, append to existing list)
+                currentEntry.OriginalMsgStrLines ??= new List<string>();
+                currentEntry.OriginalMsgStrLines.Add(line.Trim());
                 continue;
             }
 
@@ -194,6 +201,12 @@ private async Task<List<PoEntry>> ParseEntriesAsync(TextReader reader, Cancellat
             {
                 var value = UnescapeString(match.Groups[1].Value);
                 AppendToCurrent(currentEntry, currentField, value);
+
+                // Capture original formatting for continuation lines
+                if (currentField is PoField.MsgStr or PoField.MsgStrPlural)
+                {
+                    currentEntry.OriginalMsgStrLines?.Add(line.Trim());
+                }
                 continue;
             }
         }
@@ -306,18 +319,76 @@ private ResourceEntry ConvertToResourceEntry(PoEntry poEntry, string languageCod
                 IsPlural = true,
                 PluralForms = pluralForms,
                 // Store msgid_plural for translation (source plural text)
-                SourcePluralText = poEntry.MsgIdPlural
+                SourcePluralText = poEntry.MsgIdPlural,
+                References = poEntry.References,  // Transfer references
+                // Preserve original formatting for plural forms
+                OriginalFormatting = poEntry.OriginalMsgStrLines != null && poEntry.OriginalMsgStrLines.Any()
+                    ? string.Join("\n", poEntry.OriginalMsgStrLines)
+                    : null,
+                Flags = poEntry.Flags,  // Transfer flags (fuzzy, etc.)
+                IsObsolete = poEntry.IsObsolete  // Transfer obsolete status
             };
         }
 
         return new ResourceEntry
         {
             Key = key,
             Value = poEntry.MsgStr,
-            Comment = poEntry.GetCombinedComment()
+            Comment = poEntry.GetCombinedComment(),
+            References = poEntry.References,  // Transfer references
+            // Preserve original formatting
+            OriginalFormatting = poEntry.OriginalMsgStrLines != null && poEntry.OriginalMsgStrLines.Any()
+                ? string.Join("\n", poEntry.OriginalMsgStrLines)
+                : null,
+            Flags = poEntry.Flags,  // Transfer flags (fuzzy, etc.)
+            IsObsolete = poEntry.IsObsolete  // Transfer obsolete status
         };
     }
 
+    /// <summary>
+    /// Builds the original header text from a header PoEntry for preservation.
+    /// This maintains the exact original header format including comments and metadata.
+    /// </summary>
+    private string BuildOriginalHeader(PoEntry headerEntry)
+    {
+        var sb = new StringBuilder();
+
+        // Add translator comments
+        if (!string.IsNullOrEmpty(headerEntry.TranslatorComment))
+        {
+            foreach (var line in headerEntry.TranslatorComment.Split('\n'))
+            {
+                sb.AppendLine(string.IsNullOrEmpty(line) ? "#" : $"# {line}");
+            }
+        }
+
+        // Add extracted comments
+        if (!string.IsNullOrEmpty(headerEntry.ExtractedComment))
+        {
+            foreach (var line in headerEntry.ExtractedComment.Split('\n'))
+            {
+                sb.AppendLine($"#. {line}");
+            }
+        }
+
+        // Add the header msgid and msgstr
+        sb.AppendLine("msgid \"\"");
+        sb.AppendLine("msgstr \"\"");
+
+        // Add header fields (these are already escaped in MsgStr)
+        if (!string.IsNullOrEmpty(headerEntry.MsgStr))
+        {
+            // Trim trailing newlines to avoid adding empty "\n" lines
+            var headerContent = headerEntry.MsgStr.TrimEnd('\n', '\r');
+            foreach (var line in headerContent.Split('\n'))
+            {
+                sb.AppendLine($"\"{line}\\n\"");
+            }
+        }
+
+        return sb.ToString();
+    }
+
     private static bool HasContent(PoEntry entry)
     {
         return !string.IsNullOrEmpty(entry.MsgId) ||

LocalizationManager.Core/Backends/Po/PoResourceWriter.cs

@@ -38,7 +38,8 @@ public async Task WriteAsync(ResourceFile file, CancellationToken ct = default)
 
         // Atomic write: write to temp file then rename
         var tempPath = file.Language.FilePath + ".tmp";
-        await File.WriteAllTextAsync(tempPath, content, Encoding.UTF8, ct);
+        // Use UTF-8 without BOM (PO file standard)
+        await File.WriteAllTextAsync(tempPath, content, new UTF8Encoding(false), ct);
         File.Move(tempPath, file.Language.FilePath, overwrite: true);
     }
 
@@ -122,6 +123,15 @@ public string SerializeToString(ResourceFile file)
 
     private void WriteHeader(StringBuilder sb, ResourceFile file)
     {
+        // Use preserved original header if available
+        if (!string.IsNullOrEmpty(file.OriginalHeader))
+        {
+            sb.Append(file.OriginalHeader);
+            sb.AppendLine();
+            return;
+        }
+
+        // Fall back to generating new header (for new files)
         // PO header is an entry with empty msgid
         sb.AppendLine("# PO file generated by LRM");
         sb.AppendLine("#");
@@ -152,6 +162,28 @@ private void WriteHeader(StringBuilder sb, ResourceFile file)
     }
 
     private void WriteEntry(StringBuilder sb, ResourceEntry entry, string languageCode)
+    {
+        // If obsolete, write to a temporary buffer and prefix all lines with #~
+        if (entry.IsObsolete)
+        {
+            var tempSb = new StringBuilder();
+            WriteEntryContent(tempSb, entry, languageCode);
+
+            // Prefix all lines with #~
+            var lines = tempSb.ToString().Split('\n', StringSplitOptions.RemoveEmptyEntries);
+            foreach (var line in lines)
+            {
+                sb.AppendLine($"#~ {line}");
+            }
+            sb.AppendLine();
+            return;
+        }
+
+        WriteEntryContent(sb, entry, languageCode);
+        sb.AppendLine();
+    }
+
+    private void WriteEntryContent(StringBuilder sb, ResourceEntry entry, string languageCode)
     {
         // Write comment if present
         if (!string.IsNullOrEmpty(entry.Comment))
@@ -162,6 +194,21 @@ private void WriteEntry(StringBuilder sb, ResourceEntry entry, string languageCo
             }
         }
 
+        // Write reference comments (#: file.cs:line)
+        if (entry.References != null && entry.References.Count > 0)
+        {
+            foreach (var reference in entry.References)
+            {
+                sb.AppendLine($"#: {reference}");
+            }
+        }
+
+        // Write flags (#, fuzzy, c-format, etc.)
+        if (entry.Flags != null && entry.Flags.Count > 0)
+        {
+            sb.AppendLine($"#, {string.Join(", ", entry.Flags)}");
+        }
+
         // Determine if we have context (key contains |)
         string? context = null;
         var msgId = entry.Key;
@@ -200,20 +247,26 @@ private void WriteEntry(StringBuilder sb, ResourceEntry entry, string languageCo
             {
                 var category = categories[i];
                 var value = entry.PluralForms.GetValueOrDefault(category) ?? "";
-                WritePoString(sb, $"msgstr[{i}]", value);
+                WritePoString(sb, $"msgstr[{i}]", value, entry);
             }
         }
         else
         {
             // Write msgstr
-            WritePoString(sb, "msgstr", entry.Value ?? "");
+            WritePoString(sb, "msgstr", entry.Value ?? "", entry);
         }
-
-        sb.AppendLine();
     }
 
-    private void WritePoString(StringBuilder sb, string keyword, string value)
+    private void WritePoString(StringBuilder sb, string keyword, string value, ResourceEntry? entry = null)
     {
+        // Check if we can use original formatting
+        if (CanUseOriginalFormatting(entry, value, keyword))
+        {
+            sb.AppendLine(entry!.OriginalFormatting);
+            return;
+        }
+
+        // Otherwise, regenerate formatting
         var escaped = EscapeString(value);
         var prefix = $"{keyword} ";
 
@@ -385,4 +438,52 @@ private string GetLanguageDisplayName(string cultureCode)
             return cultureCode;
         }
     }
+
+    /// <summary>
+    /// Reconstructs the unescaped value from original formatting to verify it matches the current value.
+    /// </summary>
+    private string ReconstructValueFromFormatting(string originalFormatting)
+    {
+        var lines = originalFormatting.Split('\n');
+        var value = new StringBuilder();
+
+        foreach (var line in lines)
+        {
+            // Extract string content between quotes
+            var match = System.Text.RegularExpressions.Regex.Match(
+                line.Trim(), @"^(?:msgstr(?:\[\d+\])?\s+)?""(.*)""$");
+            if (match.Success)
+            {
+                // Unescape and concatenate
+                value.Append(PoResourceReader.UnescapeString(match.Groups[1].Value));
+            }
+        }
+
+        return value.ToString();
+    }
+
+    /// <summary>
+    /// Checks if we can use the original formatting for this entry.
+    /// Returns true only if the value hasn't changed from the original.
+    /// </summary>
+    private bool CanUseOriginalFormatting(ResourceEntry? entry, string currentValue, string keyword)
+    {
+        try
+        {
+            if (entry == null || string.IsNullOrEmpty(entry.OriginalFormatting))
+                return false;
+
+            var lines = entry.OriginalFormatting.Split('\n');
+            if (lines.Length == 0 || !lines[0].StartsWith(keyword))
+                return false;
+
+            var reconstructedValue = ReconstructValueFromFormatting(entry.OriginalFormatting);
+            return reconstructedValue == currentValue;
+        }
+        catch
+        {
+            // If reconstruction fails, fall back to regenerating
+            return false;
+        }
+    }
 }