rlsbl 0.7.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rlsbl",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Release orchestration and project scaffolding for npm and PyPI",
   "license": "MIT",
   "bin": {

package/rlsbl/commands/discover.py

@@ -47,10 +47,12 @@ def _parse_next_link(headers):
         return None
     for part in link.split(","):
         if 'rel="next"' in part:
-            # Extract URL between < and >
             start = part.index("<") + 1
             end = part.index(">")
-            return part[start:end]
+            url = part[start:end]
+            if not url.startswith("https://api.github.com/"):
+                return None
+            return url
     return None
 
 

package/rlsbl/commands/init_cmd.py

@@ -4,30 +4,16 @@ import hashlib
 import json
 import os
 import re
+import subprocess
 import sys
-from io import StringIO
-
-from ruamel.yaml import YAML
+import tempfile
 
 from ..config import should_tag
 from ..registries import REGISTRIES
 from ..tagging import ensure_tags
 
 HASHES_FILE = os.path.join(".rlsbl", "hashes.json")
-
-# Files where existing content is preserved and template sections are appended
-APPENDABLE = {"CLAUDE.md"}
-APPEND_MARKER = "rlsbl"
-
-# Files where missing entries from the template are merged into the existing file
-MERGEABLE = {".gitignore"}
-
-# JSON files where template keys are deep-merged into existing user content
-JSON_MERGEABLE = {".claude/settings.json"}
-
-# YAML workflow files with job-level merge: template jobs overwrite same-key user jobs,
-# user-added jobs are preserved. Top-level keys (name, on, permissions) come from template.
-YAML_MERGEABLE = {".github/workflows/ci.yml", ".github/workflows/publish.yml"}
+BASES_DIR = os.path.join(".rlsbl", "bases")
 
 # Files owned by the user after initial scaffold -- never overwrite or merge
 USER_OWNED = {
@@ -96,110 +82,80 @@ def process_template(template_content, vars_dict):
     return content, unreplaced
 
 
-def _deep_merge(base, override):
-    """Deep-merge two JSON-like structures. User values (base) take precedence.
+def _save_base(target, content):
+    """Save rendered template content as the merge base for future three-way merges."""
+    base_path = os.path.join(BASES_DIR, target)
+    os.makedirs(os.path.dirname(base_path), exist_ok=True)
+    with open(base_path, "w", encoding="utf-8") as f:
+        f.write(content)
 
-    - Dicts: recursively merge; keys only in override are added, base keys kept.
-    - Lists: union by value; base items first, then new override items (deduplicated).
-    - Scalars: base wins.
-    """
-    if isinstance(base, dict) and isinstance(override, dict):
-        merged = {}
-        for key in base:
-            if key in override:
-                merged[key] = _deep_merge(base[key], override[key])
-            else:
-                merged[key] = base[key]
-        for key in override:
-            if key not in base:
-                merged[key] = override[key]
-        return merged
-    if isinstance(base, list) and isinstance(override, list):
-        # Deduplicate by value: keep base order, append new items from override
-        seen = set()
-        for item in base:
-            # Use JSON serialization for unhashable items (dicts, lists)
-            try:
-                seen.add(item)
-            except TypeError:
-                seen.add(json.dumps(item, sort_keys=True))
-        result = list(base)
-        for item in override:
-            if isinstance(item, (dict, list)):
-                key = json.dumps(item, sort_keys=True)
-            else:
-                key = item
-            if key not in seen:
-                seen.add(key)
-                result.append(item)
-        return result
-    # Scalars: base (user) wins
-    return base
 
+def _load_base(target):
+    """Load the stored merge base for a target file. Returns None if not stored."""
+    base_path = os.path.join(BASES_DIR, target)
+    if not os.path.exists(base_path):
+        return None
+    with open(base_path, "r", encoding="utf-8") as f:
+        return f.read()
 
-def _yaml_merge_workflow(existing_text, template_text):
-    """Merge a YAML workflow at the job level.
 
-    Template wins for top-level keys (name, on, permissions, etc.).
-    For the 'jobs' key: template jobs overwrite same-key user jobs,
-    user-added jobs not in the template are preserved at the end.
+def _three_way_merge(ours_text, base_text, theirs_text):
+    """Three-way merge using git merge-file.
 
-    Returns (merged_text, error_msg). error_msg is None on success.
+    Writes three temp files in the project dir (not /tmp), runs
+    `git merge-file -p ours base theirs`, and returns (merged_text, has_conflicts).
+    Exit code: 0 = clean merge, positive = number of conflicts, negative = error.
     """
-    yaml = YAML(typ="rt")
-    yaml.preserve_quotes = True
-    try:
-        existing = yaml.load(existing_text)
-    except Exception as e:
-        return None, f"failed to parse existing YAML: {e}"
+    ours_tmp = theirs_tmp = base_tmp = None
     try:
-        template = yaml.load(template_text)
-    except Exception as e:
-        return None, f"failed to parse template YAML: {e}"
-
-    if not isinstance(existing, dict) or not isinstance(template, dict):
-        return None, "YAML root is not a mapping"
-
-    # Start with template as the base (template wins for top-level keys)
-    merged = type(template)()
-    for key in template:
-        merged[key] = template[key]
-
-    # Merge jobs: template jobs first (overwriting user jobs with same key),
-    # then append user-only jobs
-    template_jobs = template.get("jobs") or {}
-    existing_jobs = existing.get("jobs") or {}
-
-    merged_jobs = type(template_jobs)() if template_jobs else type(existing_jobs)()
-    # Template jobs in template order
-    for job_key in template_jobs:
-        merged_jobs[job_key] = template_jobs[job_key]
-    # User-added jobs not in template, preserved at the end
-    for job_key in existing_jobs:
-        if job_key not in template_jobs:
-            merged_jobs[job_key] = existing_jobs[job_key]
-    merged["jobs"] = merged_jobs
-
-    # Preserve any user top-level keys not in the template (rare, but safe)
-    for key in existing:
-        if key not in merged:
-            merged[key] = existing[key]
-
-    buf = StringIO()
-    yaml.dump(merged, buf)
-    return buf.getvalue(), None
+        ours_tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".ours", dir=".", delete=False, encoding="utf-8",
+        )
+        ours_tmp.write(ours_text)
+        ours_tmp.close()
+
+        base_tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".base", dir=".", delete=False, encoding="utf-8",
+        )
+        base_tmp.write(base_text)
+        base_tmp.close()
+
+        theirs_tmp = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".theirs", dir=".", delete=False, encoding="utf-8",
+        )
+        theirs_tmp.write(theirs_text)
+        theirs_tmp.close()
+
+        result = subprocess.run(
+            ["git", "merge-file", "-p", ours_tmp.name, base_tmp.name, theirs_tmp.name],
+            capture_output=True, text=True,
+        )
+        merged_text = result.stdout
+        # Exit code 0 = clean, positive = number of conflicts, negative = error
+        has_conflicts = result.returncode > 0
+        if result.returncode < 0:
+            # Treat errors as conflicts so the caller knows something went wrong
+            has_conflicts = True
+        return merged_text, has_conflicts
+    finally:
+        for tmp in (ours_tmp, base_tmp, theirs_tmp):
+            if tmp is not None:
+                try:
+                    os.unlink(tmp.name)
+                except OSError:
+                    pass
 
 
 def process_mappings(template_dir, mappings, vars_dict, force, update=False,
                      existing_hashes=None):
     """Process a list of template mappings: read each template, apply vars, write target files.
 
-    Skips existing files unless force is True, with special handling:
-    - APPENDABLE files: append template sections if the marker is not already present
-    - MERGEABLE files: merge missing entries from the template into the existing file
-    - JSON_MERGEABLE files: deep-merge template JSON into existing (user values preserved)
-    - YAML_MERGEABLE files: job-level merge for CI workflows (template jobs win, user jobs preserved)
+    Uses a universal three-way merge (via git merge-file) for existing files:
+    base (last scaffolded version) + ours (user's current file) + theirs (new template).
+    USER_OWNED files are never overwritten or merged (except LICENSE year update).
+
     Returns (created, skipped, warnings, new_hashes).
+    created/skipped are lists of (target, status) tuples for unified display.
     """
     if existing_hashes is None:
         existing_hashes = {}
@@ -217,166 +173,132 @@ def process_mappings(template_dir, mappings, vars_dict, force, update=False,
             warnings.append(f"Template not found: {template_path}")
             continue
 
-        # When file exists and force is not set, use context-aware handling
-        if os.path.exists(target) and not force:
-            basename = os.path.basename(target)
-
-            # User-owned files are never touched after initial scaffold,
-            # except LICENSE gets its copyright year updated on --update.
-            if target in USER_OWNED:
-                if update and target == "LICENSE":
-                    from datetime import datetime
-                    current_year = str(datetime.now().year)
-                    with open(target, "r", encoding="utf-8") as f:
-                        content = f.read()
-                    # Match "Copyright (c) YYYY" or "Copyright (c) YYYY-YYYY"
+        with open(template_path, "r", encoding="utf-8") as f:
+            raw = f.read()
+        theirs, unreplaced = process_template(raw, vars_dict)
+
+        # --- New file or force overwrite: write and save base ---
+        if not os.path.exists(target) or force:
+            is_overwrite = os.path.exists(target) and force
+            target_dir = os.path.dirname(target)
+            if target_dir and target_dir != ".":
+                os.makedirs(target_dir, exist_ok=True)
+            with open(target, "w", encoding="utf-8") as f:
+                f.write(theirs)
+            _save_base(target, theirs)
+            new_hashes[target] = file_hash(target)
+            status = "overwritten" if is_overwrite else "created"
+            created.append((target, status))
+            if unreplaced:
+                warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+            continue
+
+        # --- Existing file, not forced ---
+
+        # User-owned files: never touch after initial scaffold,
+        # except LICENSE gets its copyright year updated on --update.
+        if target in USER_OWNED:
+            if update and target == "LICENSE":
+                from datetime import datetime
+                current_year = str(datetime.now().year)
+                with open(target, "r", encoding="utf-8") as f:
+                    content = f.read()
+                # Match "Copyright (c) YYYY" or "Copyright (c) YYYY-YYYY"
+                # Capture the original end-year to report the range in the status
+                old_year = None
+                def _capture_range(m):
+                    nonlocal old_year
+                    if m.group(2) == current_year:
+                        return m.group(0)
+                    old_year = f"{m.group(1).split()[-1]}-{m.group(2)}"
+                    return f"{m.group(1)}-{current_year}"
+                updated = re.sub(
+                    r"(Copyright\s+\(c\)\s+\d{4})-(\d{4})",
+                    _capture_range,
+                    content,
+                )
+                if updated == content:
+                    # No range found or range already current -- try single year
+                    def _capture_single(m):
+                        nonlocal old_year
+                        if m.group(2) == current_year:
+                            return m.group(0)
+                        old_year = m.group(2)
+                        return f"{m.group(1)}{m.group(2)}-{current_year}"
                     updated = re.sub(
-                        r"(Copyright\s+\(c\)\s+\d{4})-(\d{4})",
-                        lambda m: (
-                            m.group(0) if m.group(2) == current_year
-                            else f"{m.group(1)}-{current_year}"
-                        ),
+                        r"(Copyright\s+\(c\)\s+)(\d{4})(?![-\d])",
+                        _capture_single,
                         content,
                     )
-                    if updated == content:
-                        # No range found or range already current -- try single year
-                        updated = re.sub(
-                            r"(Copyright\s+\(c\)\s+)(\d{4})(?![-\d])",
-                            lambda m: (
-                                m.group(0) if m.group(2) == current_year
-                                else f"{m.group(1)}{m.group(2)}-{current_year}"
-                            ),
-                            content,
-                        )
-                    if updated != content:
-                        with open(target, "w", encoding="utf-8") as f:
-                            f.write(updated)
-                        created.append("LICENSE (year updated)")
-                    else:
-                        skipped.append(target)
-                else:
-                    skipped.append(target)
-                continue
-
-            if target in JSON_MERGEABLE:
-                with open(target, "r", encoding="utf-8") as f:
-                    existing_text = f.read()
-                with open(template_path, "r", encoding="utf-8") as f:
-                    raw = f.read()
-                content, unreplaced = process_template(raw, vars_dict)
-                try:
-                    existing_data = json.loads(existing_text)
-                    template_data = json.loads(content)
-                except json.JSONDecodeError as e:
-                    warnings.append(f"{target}: JSON parse error during merge: {e}")
-                    skipped.append(target)
-                    continue
-                merged = _deep_merge(existing_data, template_data)
-                target_dir = os.path.dirname(target)
-                if target_dir and target_dir != ".":
-                    os.makedirs(target_dir, exist_ok=True)
-                with open(target, "w", encoding="utf-8") as f:
-                    f.write(json.dumps(merged, indent=2))
-                    f.write("\n")
-                created.append(target + " (merged)")
-                if unreplaced:
-                    warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
-                continue
-
-            if target in YAML_MERGEABLE:
-                with open(target, "r", encoding="utf-8") as f:
-                    existing_text = f.read()
-                with open(template_path, "r", encoding="utf-8") as f:
-                    raw = f.read()
-                content, unreplaced = process_template(raw, vars_dict)
-                merged_text, err = _yaml_merge_workflow(existing_text, content)
-                if err:
-                    warnings.append(f"{target}: YAML merge skipped: {err}")
-                    skipped.append(target)
-                    continue
-                target_dir = os.path.dirname(target)
-                if target_dir and target_dir != ".":
-                    os.makedirs(target_dir, exist_ok=True)
-                with open(target, "w", encoding="utf-8") as f:
-                    f.write(merged_text)
-                new_hashes[target] = file_hash(target)
-                created.append(target + " (merged)")
-                if unreplaced:
-                    warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
-                continue
-
-            if basename in APPENDABLE:
-                with open(target, "r", encoding="utf-8") as f:
-                    existing = f.read()
-                if APPEND_MARKER in existing:
-                    skipped.append(target + " (already has rlsbl section)")
-                    continue
-                # Append only the ## sections, stripping the top-level # heading
-                with open(template_path, "r", encoding="utf-8") as f:
-                    raw = f.read()
-                content, _ = process_template(raw, vars_dict)
-                lines = content.split("\n")
-                first_section_idx = None
-                for i, line in enumerate(lines):
-                    if i > 0 and line.startswith("## "):
-                        first_section_idx = i
-                        break
-                section = "\n".join(lines[first_section_idx:]) if first_section_idx is not None else content
-                with open(target, "a", encoding="utf-8") as f:
-                    f.write("\n\n" + section.strip() + "\n")
-                created.append(target + " (appended)")
-                continue
-
-            if basename in MERGEABLE:
-                with open(target, "r", encoding="utf-8") as f:
-                    existing = f.read()
-                with open(template_path, "r", encoding="utf-8") as f:
-                    raw = f.read()
-                content, _ = process_template(raw, vars_dict)
-                existing_lines = {
-                    line.strip() for line in existing.split("\n") if line.strip()
-                }
-                # Normalize by stripping trailing slashes so e.g.
-                # "*.egg-info/" matches "*.egg-info" and vice versa.
-                existing_normalized = {
-                    line.rstrip("/") for line in existing_lines
-                }
-                new_lines = [
-                    line.strip() for line in content.split("\n") if line.strip()
-                ]
-                # Only merge non-comment entries that are missing from the existing file
-                missing = [
-                    line for line in new_lines
-                    if line.rstrip("/") not in existing_normalized
-                    and not line.startswith("#")
-                ]
-                if missing:
-                    with open(target, "a", encoding="utf-8") as f:
-                        f.write("\n# Added by rlsbl\n" + "\n".join(missing) + "\n")
-                    created.append(f"{target} (merged {len(missing)} entries)")
+                if updated != content:
+                    with open(target, "w", encoding="utf-8") as f:
+                        f.write(updated)
+                    year_detail = (
+                        f"year updated ({old_year} -> {old_year.split('-')[0]}-{current_year})"
+                        if old_year and "-" in old_year
+                        else f"year updated ({old_year} -> {old_year}-{current_year})"
+                    ) if old_year else "year updated"
+                    created.append(("LICENSE", year_detail))
                 else:
-                    skipped.append(target + " (all entries present)")
-                continue
-
-            skipped.append(target)
+                    skipped.append((target, "user-owned"))
+            else:
+                skipped.append((target, "user-owned"))
             continue
 
-        with open(template_path, "r", encoding="utf-8") as f:
-            raw = f.read()
-        content, unreplaced = process_template(raw, vars_dict)
-
-        # Ensure parent directory exists
-        target_dir = os.path.dirname(target)
-        if target_dir and target_dir != ".":
-            os.makedirs(target_dir, exist_ok=True)
-
-        with open(target, "w", encoding="utf-8") as f:
-            f.write(content)
-        new_hashes[target] = file_hash(target)
-        created.append(target)
+        # --- Three-way merge for all other existing files ---
+        with open(target, "r", encoding="utf-8") as f:
+            ours = f.read()
+        base = _load_base(target)
+
+        if base is None:
+            # No base stored (legacy project or first update after migration).
+            # Cannot do a three-way merge. Seed the base for next time.
+            _save_base(target, theirs)
+            if ours == theirs:
+                skipped.append((target, "unchanged, base seeded"))
+            else:
+                warnings.append(
+                    f"{target}: no base stored, cannot merge; "
+                    "run scaffold --force to reset"
+                )
+                skipped.append((target, "no base -- run scaffold --force to enable merging"))
+            continue
 
-        if unreplaced:
-            warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+        if ours == base:
+            # User did not customize -- clean update: write theirs.
+            target_dir = os.path.dirname(target)
+            if target_dir and target_dir != ".":
+                os.makedirs(target_dir, exist_ok=True)
+            with open(target, "w", encoding="utf-8") as f:
+                f.write(theirs)
+            _save_base(target, theirs)
+            new_hashes[target] = file_hash(target)
+            created.append((target, "updated"))
+            if unreplaced:
+                warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+        elif base == theirs:
+            # Template did not change -- nothing to do.
+            skipped.append((target, "unchanged"))
+        elif ours == theirs:
+            # User and template converged to same content -- nothing to do.
+            skipped.append((target, "unchanged"))
+        else:
+            # Both user and template changed -- three-way merge.
+            merged, has_conflicts = _three_way_merge(ours, base, theirs)
+            target_dir = os.path.dirname(target)
+            if target_dir and target_dir != ".":
+                os.makedirs(target_dir, exist_ok=True)
+            with open(target, "w", encoding="utf-8") as f:
+                f.write(merged)
+            _save_base(target, theirs)
+            new_hashes[target] = file_hash(target)
+            if has_conflicts:
+                created.append((target, "CONFLICTS -- resolve manually"))
+                warnings.append(f"{target}: merge conflicts detected, resolve manually")
+            else:
+                created.append((target, "merged"))
+            if unreplaced:
+                warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
 
     return created, skipped, warnings, new_hashes
 
@@ -431,16 +353,19 @@ def _finalize_scaffold(existing_hashes, all_hash_dicts, created, skipped, warnin
     if should_tag(flags):
         ensure_tags(registries)
 
-    # Print summary
-    if created:
-        print("Created:")
-        for f in created:
-            print(f"  {f}")
-
-    if skipped:
-        print("Skipped (already exist, use --update to refresh managed files or --force to overwrite all):")
-        for f in skipped:
-            print(f"  {f}")
+    # Print unified file list with dot-padded status column
+    all_files = [(t, s) for t, s in created] + [(t, s) for t, s in skipped]
+    if all_files:
+        # Sort by target path for stable output
+        all_files.sort(key=lambda item: item[0])
+        # Compute padding width: longest target path + minimum 4 dots
+        max_target_len = max(len(t) for t, _ in all_files)
+        pad_width = max_target_len + 4
+        print("Files:")
+        for target, status in all_files:
+            # Fill gap between target and status with dots
+            dots = " " + "." * (pad_width - len(target)) + " "
+            print(f"  {target}{dots}{status}")
 
     if warnings:
         print("Warnings:")
@@ -449,7 +374,7 @@ def _finalize_scaffold(existing_hashes, all_hash_dicts, created, skipped, warnin
 
     # Helpful note when existing CI workflow is preserved
     ci_path = ".github/workflows/ci.yml"
-    if any(s.startswith(ci_path) for s in skipped):
+    if any(t == ci_path for t, _ in skipped):
         print("\nNote: Existing CI workflow preserved. Review and merge manually if needed.")
 
     # Next steps
@@ -555,7 +480,7 @@ def run_cmd_multi(registries_list, args, flags):
 
     # Process merged publish workflow template
     merged_tpl_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)),
-                                  "..", "templates", "merged")
+                                  "templates", "merged")
     merged_created, merged_skipped, merged_warnings, merged_hashes = process_mappings(
         merged_tpl_dir,
         [{"template": "publish.yml.tpl", "target": ".github/workflows/publish.yml"}],

package/rlsbl/commands/release.py

@@ -210,6 +210,18 @@ def run_cmd(registry, args, flags):
         except Exception:
             pass
 
+    # Update .rlsbl/version marker so it's included in the release commit
+    rlsbl_version_marker = os.path.join(".rlsbl", "version")
+    if os.path.exists(os.path.dirname(rlsbl_version_marker)):
+        try:
+            from .. import __version__ as rlsbl_ver
+            with open(rlsbl_version_marker, "w") as f:
+                f.write(rlsbl_ver + "\n")
+            if rlsbl_version_marker not in files_to_commit:
+                files_to_commit.append(rlsbl_version_marker)
+        except Exception:
+            pass
+
     # Commit if anything was actually modified (version bump or tagging)
     needs_commit = new_version != current_version or not is_clean_tree()
     if files_to_commit and needs_commit:

package/rlsbl/commands/undo.py

@@ -2,12 +2,20 @@
 
 import sys
 
-from ..utils import run, check_gh_installed, check_gh_auth, get_push_timeout
+from ..utils import run, check_gh_installed, check_gh_auth, get_push_timeout, is_clean_tree
 
 
 def run_cmd(registry, args, flags):
-    check_gh_installed()
-    check_gh_auth()
+    if not check_gh_installed():
+        print("Error: gh CLI is not installed.", file=sys.stderr)
+        sys.exit(1)
+    if not check_gh_auth():
+        print("Error: gh CLI is not authenticated.", file=sys.stderr)
+        sys.exit(1)
+
+    if not is_clean_tree():
+        print("Error: working tree is not clean. Commit your changes first.", file=sys.stderr)
+        sys.exit(1)
 
     # Find the latest tag
     try:

package/rlsbl/registries/go.py

@@ -39,12 +39,12 @@ def get_version_file():
 
 def get_template_dir():
     """Returns path to the go-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "go")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "go")
 
 
 def get_shared_template_dir():
     """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "shared")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
 
 
 def get_template_vars(dir_path):

package/rlsbl/registries/npm.py

@@ -32,7 +32,7 @@ def write_version(dir_path, version):
 
     # Preserve trailing newline if present
     trailing_newline = "\n" if raw.endswith("\n") else ""
-    output = json.dumps(pkg, indent=indent) + trailing_newline
+    output = json.dumps(pkg, indent=indent, ensure_ascii=False) + trailing_newline
     # Atomic write: write to temp file, then rename
     tmp_path = pkg_path + ".tmp"
     with open(tmp_path, "w", encoding="utf-8") as f:
@@ -47,12 +47,12 @@ def get_version_file():
 
 def get_template_dir():
     """Returns path to the npm-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "npm")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "npm")
 
 
 def get_shared_template_dir():
     """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "shared")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
 
 
 def get_template_vars(dir_path):

package/rlsbl/registries/pypi.py

@@ -67,12 +67,12 @@ def get_version_file():
 
 def get_template_dir():
     """Returns path to the pypi-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "pypi")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "pypi")
 
 
 def get_shared_template_dir():
     """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "..", "templates", "shared")
+    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
 
 
 def get_template_vars(dir_path):

package/rlsbl/tagging.py

@@ -32,7 +32,7 @@ def ensure_npm_keyword(dir_path=".", quiet=False):
 
     # Preserve trailing newline if present
     trailing_newline = "\n" if raw.endswith("\n") else ""
-    output = json.dumps(pkg, indent=indent) + trailing_newline
+    output = json.dumps(pkg, indent=indent, ensure_ascii=False) + trailing_newline
 
     # Atomic write: write to temp file, then rename
     tmp_path = pkg_path + ".tmp"
@@ -82,11 +82,16 @@ def ensure_pypi_keyword(dir_path=".", quiet=False):
             # Find the indent used for existing items
             item_indent_match = re.search(r'\n( +)"', array_content)
             item_indent = item_indent_match.group(1) if item_indent_match else "    "
-            new_array_content = array_content.rstrip() + f',\n{item_indent}"rlsbl"\n'
+            # Strip trailing comma to avoid double comma when the list
+            # already has a trailing comma before the closing bracket
+            stripped = array_content.rstrip()
+            stripped = stripped.rstrip(",")
+            new_array_content = stripped + f',\n{item_indent}"rlsbl"\n'
         else:
             # Single-line
             if array_content.strip():
-                new_array_content = array_content.rstrip() + ', "rlsbl"'
+                stripped_sl = array_content.rstrip().rstrip(",")
+                new_array_content = stripped_sl + ', "rlsbl"'
             else:
                 new_array_content = '"rlsbl"'
         new_field = prefix + new_array_content + "]"

package/{templates → rlsbl/templates}/shared/hooks/pre-release.sh.tpl

@@ -8,15 +8,19 @@ set -euo pipefail
 echo "Running pre-release checks..."
 
 if [ -f go.mod ]; then
-  echo "Detected Go project"
+  echo "  Go: vet + build + test"
   go vet ./...
   go build ./...
   go test ./... -race -short -count=1
-elif [ -f package.json ]; then
-  echo "Detected npm project"
+fi
+
+if [ -f package.json ] && node -e "process.exit(require('./package.json').scripts?.test ? 0 : 1)" 2>/dev/null; then
+  echo "  npm: test"
   npm test
-elif [ -f pyproject.toml ]; then
-  echo "Detected Python project"
+fi
+
+if [ -f pyproject.toml ]; then
+  echo "  Python: pytest"
   if command -v uv &>/dev/null; then
     uv run pytest
   elif command -v pytest &>/dev/null; then