feat(FR-1365): auto merge i18n conflicts (#4136)

resolves #4135 ([FR-1365](https://lablup.atlassian.net/browse/FR-1365))

### Add JSON merge driver for better conflict resolution

  Enhanced the i18n JSON merge driver to automatically resolve conflicts during Git merges and added a comprehensive test suite to ensure reliability.

### Driver Settings
Even if `.gitconfig` is included in the remote branch, it may not be applied due to security concerns. Save the contents of `.gitconfig` as-is, then verify that the json-i18n driver is configured for the i18n file using the command `git check-attr merge <i18n-json-path>`.
- `git config --local include.path ../.gitconfig`

  ### Changes
1. Merge Driver Improvements
  (`scripts/i18n-merge-driver.js`)
   - **Added key sorting priority**: Ensures
  `$schema` key always appears at the top of
   JSON objects
   - **Consistent key ordering**: Applied
  stable sorting (lowercase → uppercase →
  special characters)
   - **Fixed Git configuration**: Corrected
  merge driver setup to match
  `.gitattributes`
  (`merge.json-i18n.driver`)

  ### Merge Case Scenarios
 ✅ Automatically Successful Cases
1. **Different keys modified**
     ```json
     // Base: {"key1": "value1"}
     // Ours: {"key1": "value1", "newKey": "ours"}
     // Theirs: {"key1": "value1", "anotherKey": "theirs"}
     // → Auto-merge successful

2. Same key modified identically
     ```json
   // Base: {"key1": "old"}
   // Ours: {"key1": "new"}
   // Theirs: {"key1": "new"}
   // → Auto-merge successful
  3. One-sided modifications
     ```json
     // Base: {"key1": "value1", "key2": "value2"}
     // Ours: {"key1": "modified", "key2": "value2"}
     // Theirs: {"key1": "value1", "key2": "value2"}
     // → Auto-merge successful
  4. Key addition/deletion combinations
     ```json
     // Base: {"key1": "value1", "toDelete": "will be removed"}
     // Ours: {"key1": "value1"} // Key deleted
     // Theirs: {"key1": "value1", "toDelete": "will be removed", "newKey": "added"}
     // → Auto-merge successful

  ❌ Conflict Cases

  1. Same key modified differently
     ```json
     // Base: {"key1": "original"}
     // Ours: {"key1": "changed by ours"}
     // Theirs: {"key1": "changed by theirs"}
     // → Conflict occurs, manual resolution required
  2. Nested object conflicts
     ```json
     // Base: {"comp:Button": {"label": "Click"}}
     // Ours: {"comp:Button": {"label": "클릭"}}
     // Theirs: {"comp:Button": {"label": "Press"}}
     // → Conflict occurs, manual resolution required
  3. Mixed scenarios (partial success, partial conflict)
     ```json
     // Base: {"safe": "value", "conflict": "original"}
     // Ours: {"safe": "value", "conflict": "ours", "newKey": "added"}
     // Theirs: {"safe": "value", "conflict": "theirs", "anotherKey": "added"}
     // → Conflict occurs (due to conflict key), entire merge fails

  This enhancement enables automatic handling of most i18n JSON file merge conflicts while providing test coverage to ensure stability across complex scenarios.

**Checklist:** (if applicable)

- [ ] Documentation
- [ ] Minium required manager version
- [ ] Specific setting for review (eg., KB link, endpoint or how to setup)
- [ ] Minimum requirements to check during review
- [ ] Test case(s) to demonstrate the difference of before/after

[FR-1365]: https://lablup.atlassian.net/browse/FR-1365?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

Author: ironAiken2

.gitattributes

@@ -0,0 +1,4 @@
+# Custom merge drivers for conflict resolution
+# Specifically target i18n translation files to avoid trailing comma conflicts
+resources/i18n/**/*.json merge=json-i18n
+packages/backend.ai-ui/src/locale/*.json merge=json-i18n

.gitconfig

@@ -0,0 +1,3 @@
+[merge "json-i18n"]
+  name = i18n JSON 3-way merge (sorted, conflict on same path)
+  driver = node scripts/i18n-merge-driver.js %O %A %B

package.json

@@ -228,6 +228,10 @@
       "json",
       "node"
     ],
-    "rootDir": "src"
+    "rootDir": "./",
+    "roots": [
+      "scripts",
+      "src"
+    ]
   }
 }

scripts/i18n-merge-driver.js

@@ -0,0 +1,109 @@
+const { readFileSync, writeFileSync } = require("fs");
+
+function readJSON(p) {
+  return JSON.parse(readFileSync(p, "utf8"));
+}
+function isObject(v) {
+  return v && typeof v === "object" && !Array.isArray(v);
+}
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+// Use prettier to sort JSON objects
+async function sortObject(obj) {
+  // Lazy load prettier to avoid issues in test environment
+  const prettier = require("prettier");
+
+  // Format the JSON using prettier with inline config
+  const formatted = await prettier.format(JSON.stringify(obj), {
+    parser: "json",
+    plugins: ["prettier-plugin-sort-json"],
+    jsonRecursiveSort: true,
+  });
+
+  return JSON.parse(formatted.trim());
+}
+// collect changed diff
+function diffLeaves(base, v, path = [], acc = []) {
+  if (deepEqual(base, v)) return acc; // no change
+  if (isObject(base) && isObject(v)) {
+    const keys = new Set([...Object.keys(base), ...Object.keys(v)]);
+    for (const key of keys) {
+      const baseValue = base[key];
+      const newValue = v[key];
+      diffLeaves(baseValue, newValue, [...path, key], acc);
+    }
+    return acc;
+  } else {
+    acc.push({ path, value: v });
+    return acc;
+  }
+}
+
+function setAt(root, path, value) {
+  if (path.length === 0) return value;
+  let current = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const k = path[i];
+    if (!isObject(current[k])) current[k] = {};
+    current = current[k];
+  }
+  const last = path[path.length - 1];
+  if (value === undefined) {
+    // delete
+    delete current[last];
+  } else {
+    current[last] = value;
+  }
+  return root;
+}
+function pathKey(path) {
+  return path.join("\x1f");
+}
+
+// Export functions for testing
+module.exports = {
+  readJSON,
+  isObject,
+  deepEqual,
+  diffLeaves,
+  setAt,
+  pathKey,
+};
+
+// Only run the main logic if this file is executed directly
+if (require.main === module) {
+  (async () => {
+    const [, , basePath, oursPath, theirsPath] = process.argv;
+    // parsing + sorting
+    const base = await sortObject(readJSON(basePath));
+    const ours = await sortObject(readJSON(oursPath));
+    const theirs = await sortObject(readJSON(theirsPath));
+
+    // collect changed diff
+    const dOurs = diffLeaves(base, ours);
+    const dTheirs = diffLeaves(base, theirs);
+
+    // occur conflicts when both sides have changes
+    const mOurs = new Map(dOurs.map((e) => [pathKey(e.path), e]));
+    const mTheirs = new Map(dTheirs.map((e) => [pathKey(e.path), e]));
+    for (const [k, o] of mOurs) {
+      if (mTheirs.has(k)) {
+        const t = mTheirs.get(k);
+        if (!deepEqual(o.value, t.value)) {
+          console.error("i18n JSON merge conflict at path:", o.path.join("."));
+          process.exit(1);
+        }
+      }
+    }
+
+    // merge: base -> ours -> theirs
+    let result = JSON.parse(JSON.stringify(base));
+    for (const e of dOurs) result = setAt(result, e.path, e.value);
+    for (const e of dTheirs) result = setAt(result, e.path, e.value);
+
+    result = await sortObject(result);
+    writeFileSync(oursPath, JSON.stringify(result, null, 2) + "\n", "utf8");
+    process.exit(0);
+  })();
+}