rlsbl 0.6.0 → 0.8.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.8.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

@@ -4,25 +4,23 @@ import hashlib
 import json
 import os
 import re
+import subprocess
 import sys
+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"}
-
-# Files that are safe to overwrite during --update (managed files users typically don't customize)
-UPDATABLE = {
-    ".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 = {
+    "CHANGELOG.md",
+    "LICENSE",
+    ".rlsbl/hooks/pre-release.sh",
+    ".rlsbl/hooks/post-release.sh",
 }
 
 def file_hash(path):
@@ -84,17 +82,80 @@ def process_template(template_content, vars_dict):
     return content, unreplaced
 
 
+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)
+
+
+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 _three_way_merge(ours_text, base_text, theirs_text):
+    """Three-way merge using git merge-file.
+
+    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.
+    """
+    ours_tmp = theirs_tmp = base_tmp = None
+    try:
+        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
-    - UPDATABLE files (with --update): overwrite only if the file hasn't been customized
-      (detected via SHA-256 hash comparison against stored hashes)
+    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 = {}
@@ -112,107 +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)
-
-            # 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)}")
-                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)")
-                continue
+        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
 
-            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:
+        # --- 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:
-                    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)")
+                    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])",
+                        _capture_single,
+                        content,
+                    )
+                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
 
@@ -267,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:")
@@ -285,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

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)