Fix ResourceFileParser to preserve file order and structure

Problem:
- Write() was re-ordering entries alphabetically
- Removed all data elements, losing XSD schema
- Caused unnecessary git diffs when editing files

Solution:
- Rewrote Write() to update entries in-place
- Preserves original order and XML structure
- Only modifies changed values
- New entries added at end

Tests: Added 5 comprehensive tests for file preservation
Demo: Added demo.sh with backup/restore, recorded GIF
Docs: Added demo GIF creation guide to CONTRIBUTING.md

All 26 tests passing.

Author: nickprotop

CONTRIBUTING.md

@@ -233,16 +233,24 @@ public void Validate_ShouldDetectMissingKeys_WhenTranslationIsMissing()
 
 ## Release Process
 
-Releases are automated via GitHub Actions:
+Releases are fully automated via GitHub Actions:
 
-1. Maintainer runs: `./bump-version.sh patch` (or `minor`/`major`)
-2. Commits version changes
-3. Pushes tag: `git tag release-patch && git push origin release-patch`
-4. GitHub Actions automatically:
-   - Runs tests
-   - Builds all platforms
-   - Creates GitHub release
-   - Uploads binaries
+1. Maintainer pushes a release tag: `git tag release-patch && git push origin release-patch`
+   - Use `release-patch` for bug fixes (0.6.2 → 0.6.3)
+   - Use `release-minor` for new features (0.6.2 → 0.7.0)
+   - Use `release-major` for breaking changes (0.6.2 → 1.0.0)
+
+2. GitHub Actions workflow automatically:
+   - Bumps version in `.csproj` and `README.md`
+   - Updates `CHANGELOG.md` with new version and date
+   - Commits version changes back to main
+   - Creates version tag (e.g., `v0.6.3`)
+   - Runs all tests
+   - Builds all 4 platforms (Linux/Windows x64/ARM64)
+   - Creates GitHub release with binaries and changelog
+   - Cleans up the trigger tag
+
+**Note:** Contributors don't need to worry about version numbers or releases. Maintainers handle the release process.
 
 See [BUILDING.md](BUILDING.md) for more details.
 
@@ -286,6 +294,56 @@ git merge upstream/main
 git push origin main
 ```
 
+## Creating Demo GIF
+
+If you need to update or recreate the demo GIF (e.g., after adding new features):
+
+### Prerequisites
+
+- `asciinema` for recording terminal sessions
+- `agg` for converting recordings to GIF
+
+### Installation
+
+```bash
+# Install asciinema (if not already installed)
+sudo apt-get install asciinema
+
+# Download pre-built agg binary
+wget https://github.com/asciinema/agg/releases/download/v1.4.3/agg-x86_64-unknown-linux-gnu -O agg
+chmod +x agg
+sudo mv agg /usr/local/bin/
+```
+
+### Recording Process
+
+```bash
+# 1. Build the project first
+./build.sh
+
+# 2. Set optimal terminal size (120x30)
+resize -s 30 120
+
+# 3. Record the demo (runs demo.sh automatically)
+asciinema rec lrm-demo.cast -c ./demo.sh
+
+# 4. Convert to GIF
+agg lrm-demo.cast lrm-demo.gif --speed 1.5 --font-size 14 --theme monokai
+
+# 5. Move to assets folder
+mv lrm-demo.gif assets/
+
+# 6. Commit the updated GIF
+git add assets/lrm-demo.gif
+git commit -m "Update demo GIF with latest features"
+```
+
+**Notes:**
+- The `demo.sh` script automatically backs up and restores test data
+- Terminal size 120x30 is optimal for GitHub README display
+- Speed 1.5x provides good balance between watchability and brevity
+- Use `monokai` theme for consistency with existing demo
+
 ## Getting Help
 
 - **Questions?** Open a [GitHub Discussion](https://github.com/nickprotop/LocalizationManager/discussions)

Core/ResourceFileParser.cs

@@ -84,7 +84,7 @@ public ResourceFile Parse(LanguageInfo language)
     }
 
     /// <summary>
-    /// Writes a ResourceFile back to disk, preserving XML structure.
+    /// Writes a ResourceFile back to disk, preserving XML structure and original entry order.
     /// </summary>
     /// <param name="resourceFile">The resource file to write.</param>
     /// <exception cref="InvalidOperationException">Thrown when writing fails.</exception>
@@ -97,26 +97,80 @@ public void Write(ResourceFile resourceFile)
                 ? XDocument.Load(resourceFile.Language.FilePath)
                 : CreateNewResxDocument();
 
-            // Remove all existing data elements
-            xdoc.Root?.Elements("data").Remove();
-
-            // Add updated data elements
-            foreach (var entry in resourceFile.Entries.OrderBy(e => e.Key))
+            var root = xdoc.Root;
+            if (root == null)
             {
-                var dataElement = new XElement("data",
-                    new XAttribute("name", entry.Key),
-                    new XAttribute(XNamespace.Xml + "space", "preserve"));
+                throw new InvalidOperationException("Invalid XML structure: missing root element");
+            }
 
-                // Add value element
-                dataElement.Add(new XElement("value", entry.Value ?? string.Empty));
+            // Build a dictionary of new entries for quick lookup
+            var newEntries = resourceFile.Entries.ToDictionary(e => e.Key);
+            var processedKeys = new HashSet<string>();
 
-                // Add comment if present
-                if (!string.IsNullOrEmpty(entry.Comment))
+            // Update existing data elements in place (preserves original order)
+            foreach (var dataElement in root.Elements("data").ToList())
+            {
+                var key = dataElement.Attribute("name")?.Value;
+                if (string.IsNullOrEmpty(key)) continue;
+
+                if (newEntries.TryGetValue(key, out var entry))
+                {
+                    // Update existing entry in place
+                    var valueElement = dataElement.Element("value");
+                    if (valueElement != null)
+                    {
+                        valueElement.Value = entry.Value ?? string.Empty;
+                    }
+                    else
+                    {
+                        dataElement.Add(new XElement("value", entry.Value ?? string.Empty));
+                    }
+
+                    // Update or add comment
+                    var commentElement = dataElement.Element("comment");
+                    if (!string.IsNullOrEmpty(entry.Comment))
+                    {
+                        if (commentElement != null)
+                        {
+                            commentElement.Value = entry.Comment;
+                        }
+                        else
+                        {
+                            dataElement.Add(new XElement("comment", entry.Comment));
+                        }
+                    }
+                    else if (commentElement != null)
+                    {
+                        // Remove comment if it's now empty
+                        commentElement.Remove();
+                    }
+
+                    processedKeys.Add(key);
+                }
+                else
                 {
-                    dataElement.Add(new XElement("comment", entry.Comment));
+                    // Remove entries that are no longer present
+                    dataElement.Remove();
                 }
+            }
+
+            // Add new entries that weren't in the original file (at the end)
+            foreach (var entry in resourceFile.Entries)
+            {
+                if (!processedKeys.Contains(entry.Key))
+                {
+                    var dataElement = new XElement("data",
+                        new XAttribute("name", entry.Key),
+                        new XAttribute(XNamespace.Xml + "space", "preserve"),
+                        new XElement("value", entry.Value ?? string.Empty));
+
+                    if (!string.IsNullOrEmpty(entry.Comment))
+                    {
+                        dataElement.Add(new XElement("comment", entry.Comment));
+                    }
 
-                xdoc.Root?.Add(dataElement);
+                    root.Add(dataElement);
+                }
             }
 
             // Save with proper formatting