rlsbl 0.6.0 → 0.7.0

package/README.md

@@ -145,7 +145,7 @@ When you run `release`, the following happens in order:
 | `.rlsbl/hooks/post-release.sh` | Shared | User-customizable post-release actions |
 | `.git/hooks/pre-push` | Shared | One-liner that calls `rlsbl pre-push-check` |
 
-Hook files are made executable automatically. The `check-prs`, `record-gif`, and `pre-push-check` functionality is provided as built-in subcommands (`rlsbl check-prs`, `rlsbl record-gif`, `rlsbl pre-push-check`) rather than scaffolded scripts.
+Hook files are made executable automatically. The `record-gif` and `pre-push-check` functionality is provided as built-in subcommands (`rlsbl record-gif`, `rlsbl pre-push-check`) rather than scaffolded scripts.
 
 The scaffolded `.gitignore` includes a `*.local-only` pattern. Create a `.local-only/` directory or rename files with a `.local-only` suffix to keep them out of version control -- useful for local-only assets, experiments, and keeping the working tree clean for tools that check `git status`.
 

package/package.json

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

package/rlsbl/__init__.py

@@ -40,7 +40,7 @@ __version__ = _detect_version()
 
 REGISTRIES = ("npm", "pypi", "go")
 COMMANDS = ("release", "status", "scaffold", "check", "config", "undo", "discover", "watch",
-            "check-prs", "pre-push-check", "record-gif")
+            "pre-push-check", "record-gif")
 COMMAND_ALIASES = {"init": "scaffold"}
 
 HELP = f"""\
@@ -55,7 +55,6 @@ Usage:
   rlsbl undo [--yes]                                        Revert the last release
   rlsbl discover [--mine]                                   List rlsbl ecosystem projects
   rlsbl watch [<commit-sha>]                                Watch CI runs for a commit
-  rlsbl check-prs                                          List open PRs (informational)
   rlsbl pre-push-check                                     Verify CHANGELOG entry for current version
   rlsbl record-gif                                         Record a demo GIF with vhs
 
@@ -124,7 +123,6 @@ def _get_command_module(command):
         "undo": "undo",
         "discover": "discover",
         "watch": "watch",
-        "check-prs": "check_prs",
         "pre-push-check": "pre_push_check",
         "record-gif": "record_gif",
     }
@@ -226,7 +224,7 @@ def main():
         elif command == "watch":
             # watch: monitors CI runs, no registry needed
             handler.run_cmd(registry, args, flags)
-        elif command in ("check-prs", "pre-push-check", "record-gif"):
+        elif command in ("pre-push-check", "record-gif"):
             # Standalone commands, no registry needed
             handler.run_cmd(registry, args, flags)
         else:

package/rlsbl/commands/init_cmd.py

@@ -5,6 +5,9 @@ import json
 import os
 import re
 import sys
+from io import StringIO
+
+from ruamel.yaml import YAML
 
 from ..config import should_tag
 from ..registries import REGISTRIES
@@ -19,10 +22,19 @@ APPEND_MARKER = "rlsbl"
 # Files where missing entries from the template are merged into the existing file
 MERGEABLE = {".gitignore"}
 
-# Files that are safe to overwrite during --update (managed files users typically don't customize)
-UPDATABLE = {
-    ".github/workflows/ci.yml",
-    ".github/workflows/publish.yml",
+# 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"}
+
+# Files owned by the user after initial scaffold -- never overwrite or merge
+USER_OWNED = {
+    "CHANGELOG.md",
+    "LICENSE",
+    ".rlsbl/hooks/pre-release.sh",
+    ".rlsbl/hooks/post-release.sh",
 }
 
 def file_hash(path):
@@ -84,6 +96,100 @@ 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.
+
+    - 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 _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.
+
+    Returns (merged_text, error_msg). error_msg is None on success.
+    """
+    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}"
+    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
+
+
 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.
@@ -91,9 +197,8 @@ def process_mappings(template_dir, mappings, vars_dict, force, update=False,
     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
-    - UPDATABLE files (with --update): overwrite only if the file hasn't been customized
-      (detected via SHA-256 hash comparison against stored hashes)
-
+    - 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)
     Returns (created, skipped, warnings, new_hashes).
     """
     if existing_hashes is None:
@@ -116,29 +221,88 @@ def process_mappings(template_dir, mappings, vars_dict, force, update=False,
         if os.path.exists(target) and not force:
             basename = os.path.basename(target)
 
-            # In --update mode, overwrite managed files only if not customized
-            if update and target in UPDATABLE:
-                current_hash = file_hash(target)
-                stored_hash = existing_hashes.get(target)
-                if stored_hash and current_hash == stored_hash:
-                    # File matches stored hash -- not customized, safe to overwrite
-                    with open(template_path, "r", encoding="utf-8") as f:
-                        raw = f.read()
-                    content, unreplaced = process_template(raw, vars_dict)
-                    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 + " (updated)")
-                    if unreplaced:
-                        warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+            # 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"
+                    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}"
+                        ),
+                        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:
-                    # File was customized or no stored hash -- skip conservatively
-                    # Seed the hash so future --update can detect changes
-                    new_hashes[target] = current_hash
-                    skipped.append(f"{target} (customized, use --force to overwrite)")
+                    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:

package/templates/shared/claude-settings.json.tpl

@@ -1,15 +1,3 @@
 {
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "rlsbl check-prs"
-          }
-        ]
-      }
-    ]
-  }
+  "hooks": {}
 }

package/rlsbl/commands/check_prs.py

@@ -1,26 +0,0 @@
-"""Check-prs command: list open PRs for awareness."""
-
-import shutil
-import subprocess
-import sys
-
-
-def run_cmd(registry, args, flags):
-    """List open pull requests in the current repository.
-
-    Exits silently if gh CLI is not available. Always exits 0 (informational only).
-    """
-    if not shutil.which("gh"):
-        sys.exit(0)
-
-    try:
-        result = subprocess.run(
-            ["gh", "pr", "list", "--state", "open", "--limit", "20"],
-            capture_output=True, text=True, timeout=15,
-        )
-        if result.returncode == 0 and result.stdout.strip():
-            print(result.stdout.strip())
-    except Exception:
-        pass
-
-    sys.exit(0)