rlsbl 0.1.1 → 0.3.0

package/README.md

@@ -25,7 +25,7 @@ rlsbl release minor
 
 ## Commands
 
-All commands work at the top level -- registries are auto-detected from project files (`package.json`, `pyproject.toml`). Use the registry-specific form (`rlsbl <registry> <command>`) only when you need to target a single registry.
+All commands work at the top level -- registries are auto-detected from project files (`package.json`, `pyproject.toml`). Use `--registry <npm|pypi>` when you need to target a specific registry.
 
 ### scaffold [--force] [--update]
 
@@ -33,8 +33,8 @@ Scaffolds CI/CD infrastructure and release tooling for all detected registries.
 
 ```
 rlsbl scaffold
-rlsbl npm scaffold          # target npm only
-rlsbl pypi scaffold --force # overwrite existing files
+rlsbl scaffold --registry npm          # target npm only
+rlsbl scaffold --registry pypi --force # overwrite existing files
 ```
 
 Context-aware behavior when files already exist (without `--force`):
@@ -52,7 +52,7 @@ Bumps version, commits, pushes, and creates a GitHub Release. Defaults to `patch
 
 ```
 rlsbl release minor
-rlsbl npm release major --dry-run
+rlsbl release major --dry-run --registry npm
 ```
 
 The version is synced across all detected project files (`package.json`, `pyproject.toml`) regardless of which registry is primary.
@@ -65,16 +65,16 @@ Shows project status: package name, version (per registry), git branch, last tag
 
 ```
 rlsbl status
-rlsbl pypi status
+rlsbl status --registry pypi
 ```
 
-### check-name \<name\>
+### check \<name\>
 
 Checks name availability on both npm and PyPI, and warns about confusingly similar names.
 
 ```
-rlsbl check-name my-cool-lib
-rlsbl npm check-name my-cool-lib   # npm only
+rlsbl check my-cool-lib
+rlsbl check my-cool-lib --registry npm   # npm only
 ```
 
 npm checks variant spellings (hyphens, underscores, dots, no separator). PyPI normalizes per PEP 503 and checks common alternatives.

package/package.json

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

package/rlsbl/__init__.py

@@ -10,22 +10,24 @@ except Exception:
     __version__ = "unknown"
 
 REGISTRIES = ("npm", "pypi")
-COMMANDS = ("release", "status", "scaffold", "check-name")
+COMMANDS = ("release", "status", "scaffold", "check", "config", "undo")
 COMMAND_ALIASES = {"init": "scaffold"}
 
 HELP = f"""\
 rlsbl v{__version__} -- Release orchestration and project scaffolding for npm and PyPI
 
 Usage:
-  rlsbl release [patch|minor|major] [--dry-run] [--quiet]  Orchestrate a release
-  rlsbl status                                             Show project status
+  rlsbl release [patch|minor|major] [--dry-run] [--yes] [--quiet]  Orchestrate a release
+  rlsbl status                                              Show project status
   rlsbl scaffold [--force] [--update]                       Scaffold release infrastructure
-  rlsbl check-name <name>                                  Check name availability
+  rlsbl check <name>                                        Check name availability
+  rlsbl config                                              Show project configuration
+  rlsbl undo [--yes]                                        Revert the last release
 
-  Registry-specific (when you need to target one):
-  rlsbl <registry> <command> [args...]
-
-Registries: {', '.join(REGISTRIES)}"""
+Options:
+  --registry <npm|pypi>  Target a specific registry (auto-detected if omitted)
+  --help, -h             Show this help
+  --version, -v          Show version"""
 
 
 def detect_registries():
@@ -42,19 +44,33 @@ def detect_registries():
 
 
 def parse_args(argv):
-    """Parse sys.argv into positional args and flags."""
+    """Parse sys.argv into positional args and flags.
+
+    Flags listed in VALUE_FLAGS consume the next token as their value
+    (e.g. --registry npm). All other --flags are boolean.
+    """
+    VALUE_FLAGS = ("registry",)
     raw = argv[1:]
     positional = []
     flags = {}
-
-    for arg in raw:
+    i = 0
+    while i < len(raw):
+        arg = raw[i]
         if arg.startswith("--"):
-            flags[arg[2:]] = True
+            key = arg[2:]
+            if "=" in key:
+                k, v = key.split("=", 1)
+                flags[k] = v
+            elif key in VALUE_FLAGS and i + 1 < len(raw) and not raw[i + 1].startswith("-"):
+                flags[key] = raw[i + 1]
+                i += 1
+            else:
+                flags[key] = True
         elif arg.startswith("-") and len(arg) == 2:
             flags[arg[1:]] = True
         else:
             positional.append(arg)
-
+        i += 1
     return positional, flags
 
 
@@ -65,7 +81,9 @@ def _get_command_module(command):
         "release": "release",
         "status": "status",
         "scaffold": "init_cmd",
-        "check-name": "check_name",
+        "check": "check",
+        "config": "config",
+        "undo": "undo",
     }
     module_name = module_map.get(command)
     if not module_name:
@@ -88,49 +106,31 @@ def main():
         print(__version__)
         sys.exit(0)
 
-    first = positional[0] if positional else None
+    command = positional[0] if positional else None
 
     # Resolve command aliases (e.g. "init" -> "scaffold")
-    if first in COMMAND_ALIASES:
-        first = COMMAND_ALIASES[first]
+    if command in COMMAND_ALIASES:
+        command = COMMAND_ALIASES[command]
 
-    if not first:
+    if not command:
         print("Error: missing command.\n", file=sys.stderr)
         print(HELP, file=sys.stderr)
         sys.exit(1)
 
-    registry = None
-    command = None
-    args = []
-
-    if first in COMMANDS:
-        # Top-level: rlsbl <command> ... -- auto-detect registry
-        command = first
-        args = positional[1:]
-    elif first in REGISTRIES:
-        # Registry-prefixed: rlsbl <registry> <command> ...
-        registry = first
-        command = positional[1] if len(positional) > 1 else None
-        if command and command in COMMAND_ALIASES:
-            command = COMMAND_ALIASES[command]
-
-        if not command:
-            print(f'Error: missing command for registry "{registry}".\n', file=sys.stderr)
-            print(HELP, file=sys.stderr)
-            sys.exit(1)
+    if command not in COMMANDS:
+        print(f'Error: unknown command "{command}".\n', file=sys.stderr)
+        print(HELP, file=sys.stderr)
+        sys.exit(1)
 
-        if command not in COMMANDS:
-            print(
-                f'Error: unknown command "{command}". Valid commands: {", ".join(COMMANDS)}\n',
-                file=sys.stderr,
-            )
-            print(HELP, file=sys.stderr)
-            sys.exit(1)
+    args = positional[1:]
+    registry = flags.get("registry")
 
-        args = positional[2:]
-    else:
-        print(f'Error: unknown command or registry "{first}".\n', file=sys.stderr)
-        print(HELP, file=sys.stderr)
+    # Validate --registry if provided
+    if registry and registry not in REGISTRIES:
+        print(
+            f"Error: unknown registry '{registry}'. Valid: {', '.join(REGISTRIES)}",
+            file=sys.stderr,
+        )
         sys.exit(1)
 
     try:
@@ -139,36 +139,49 @@ def main():
             print(f'Error: command "{command}" is not yet implemented.', file=sys.stderr)
             sys.exit(1)
 
-        if registry:
-            # Explicit registry -- single invocation
-            handler.run_cmd(registry, args, flags)
-        elif command == "check-name":
-            # Top-level check-name: check ALL registries
-            regs = ["npm", "pypi"]
-            for i, r in enumerate(regs):
-                handler.run_cmd(r, args, flags)
-                if i < len(regs) - 1:
-                    print("")
+        if command == "check":
+            # check: if registry given, check that one; otherwise check all
+            if registry:
+                handler.run_cmd(registry, args, flags)
+            else:
+                for i, r in enumerate(["npm", "pypi"]):
+                    handler.run_cmd(r, args, flags)
+                    if i < 1:
+                        print("")
         elif command == "scaffold":
-            # Top-level scaffold: scaffold for each detected registry
+            if registry:
+                handler.run_cmd(registry, args, flags)
+            else:
+                regs = detect_registries()
+                if not regs:
+                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    sys.exit(1)
+                if len(regs) > 1:
+                    handler.run_cmd_multi(regs, args, flags)
+                else:
+                    handler.run_cmd(regs[0], args, flags)
+        elif command == "config":
+            # config: auto-detect, pass first registry or fallback
             regs = detect_registries()
-            if not regs:
-                print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
-                sys.exit(1)
-            if len(regs) > 1:
-                # Multi-registry: only scaffold for the primary registry
-                # (CI/publish workflows conflict when both registries target the same paths)
-                print(f"Multiple registries detected: {', '.join(regs)}")
-                print(f"Scaffolding for primary registry: {regs[0]}")
-                print("For dual-registry projects, manually configure workflows with both jobs.")
-            handler.run_cmd(regs[0], args, flags)
+            handler.run_cmd(registry or (regs[0] if regs else "npm"), args, flags)
+        elif command == "undo":
+            # undo: auto-detect like release
+            if not registry:
+                regs = detect_registries()
+                if not regs:
+                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    sys.exit(1)
+                registry = regs[0]
+            handler.run_cmd(registry, args, flags)
         else:
-            # Top-level release/status: use primary detected registry
-            regs = detect_registries()
-            if not regs:
-                print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
-                sys.exit(1)
-            handler.run_cmd(regs[0], args, flags)
+            # release, status: use explicit registry or auto-detect primary
+            if not registry:
+                regs = detect_registries()
+                if not regs:
+                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    sys.exit(1)
+                registry = regs[0]
+            handler.run_cmd(registry, args, flags)
     except Exception as e:
         print(f"Error: {e}", file=sys.stderr)
         sys.exit(1)

package/rlsbl/commands/{check_name.py → check.py}

@@ -1,4 +1,4 @@
-"""Check-name command: check package name availability on npm or PyPI."""
+"""Check command: check package name availability on npm or PyPI."""
 
 import re
 import subprocess
@@ -166,14 +166,14 @@ def _check_name_pypi(name):
 
 
 def run_cmd(registry, args, flags):
-    """Check-name command handler.
+    """Check command handler.
 
     Checks package name availability on npm or PyPI, and warns about similar names.
     """
     name = args[0] if args else None
     if not name:
         print(
-            "Error: missing package name. Usage: rlsbl check-name <name>",
+            "Error: missing package name. Usage: rlsbl check <name>",
             file=sys.stderr,
         )
         sys.exit(1)

package/rlsbl/commands/config.py

@@ -0,0 +1,48 @@
+"""Config command: show resolved project configuration."""
+
+import os
+from ..registries import REGISTRIES
+
+
+def run_cmd(registry, args, flags):
+    print("Detected registries:")
+    for name, reg in REGISTRIES.items():
+        if reg.check_project_exists("."):
+            version = reg.read_version(".")
+            print(f"  {name}: {reg.get_version_file()} (v{version})")
+        else:
+            print(f"  {name}: not found")
+
+    print("\nScaffolding:")
+    rlsbl_dir = os.path.join(".", ".rlsbl")
+    if os.path.isdir(rlsbl_dir):
+        version_file = os.path.join(rlsbl_dir, "version")
+        if os.path.exists(version_file):
+            with open(version_file) as f:
+                scaffold_ver = f.read().strip()
+            print(f"  Version marker: {scaffold_ver}")
+        hashes_file = os.path.join(rlsbl_dir, "hashes.json")
+        if os.path.exists(hashes_file):
+            import json
+            with open(hashes_file) as f:
+                hashes = json.load(f)
+            print(f"  Tracked files: {len(hashes)}")
+            for path in sorted(hashes):
+                print(f"    {path}")
+    else:
+        print("  Not scaffolded (run 'rlsbl scaffold')")
+
+    print("\nWorkflows:")
+    for wf in ["ci.yml", "publish.yml", "workflow.yml"]:
+        path = os.path.join(".github", "workflows", wf)
+        print(f"  {wf}: {'yes' if os.path.exists(path) else 'no'}")
+
+    print("\nHooks:")
+    pre_release = os.path.join("scripts", "pre-release.sh")
+    print(f"  pre-release.sh: {'yes' if os.path.exists(pre_release) else 'no'}")
+    pre_push = os.path.join(".git", "hooks", "pre-push")
+    print(f"  pre-push hook: {'installed' if os.path.exists(pre_push) else 'not installed'}")
+
+    print("\nFiles:")
+    for f in ["CHANGELOG.md", "LICENSE", ".gitignore", "CLAUDE.md"]:
+        print(f"  {f}: {'yes' if os.path.exists(f) else 'no'}")

package/rlsbl/commands/init_cmd.py

@@ -53,12 +53,12 @@ NEXT_STEPS = {
     "npm": [
         "Add an NPM_TOKEN secret to your GitHub repo (Settings > Secrets > Actions)",
         "Push to GitHub to activate the CI workflow",
-        "Run rlsbl npm release [patch|minor|major]",
+        "Run rlsbl release [patch|minor|major]",
     ],
     "pypi": [
         "Push to GitHub",
         "Configure Trusted Publishing on pypi.org",
-        "Run rlsbl pypi release [patch|minor|major]",
+        "Run rlsbl release [patch|minor|major]",
     ],
 }
 
@@ -208,52 +208,12 @@ def process_mappings(template_dir, mappings, vars_dict, force, update=False,
     return created, skipped, warnings, new_hashes
 
 
-def run_cmd(registry, args, flags):
-    """Init command handler.
+def _finalize_scaffold(existing_hashes, all_hash_dicts, created, skipped, warnings,
+                       registry=None):
+    """Shared post-processing for scaffold: chmod, hooks, version marker, hashes, summary.
 
-    Scaffolds release infrastructure (CI, publish workflows, changelog, etc.)
-    from templates.
+    all_hash_dicts is a list of dicts to merge into existing_hashes.
     """
-    reg = REGISTRIES[registry]
-
-    # Check that a project file exists
-    if not reg.check_project_exists("."):
-        print(f"Error: no {registry} project found in current directory.", file=sys.stderr)
-        print(reg.get_project_init_hint(), file=sys.stderr)
-        sys.exit(1)
-
-    # Gather template variables
-    vars_dict = reg.get_template_vars(".")
-    from datetime import datetime
-    vars_dict["year"] = str(datetime.now().year)
-
-    force = flags.get("force", False)
-    update = flags.get("update", False)
-
-    existing_hashes = load_hashes()
-
-    # Process registry-specific templates
-    reg_created, reg_skipped, reg_warnings, reg_hashes = process_mappings(
-        reg.get_template_dir(),
-        reg.get_template_mappings(),
-        vars_dict,
-        force,
-        update,
-        existing_hashes,
-    )
-
-    # Process shared templates (skip if another registry already handled them)
-    shared_created, shared_skipped, shared_warnings, shared_hashes = [], [], [], {}
-    if not flags.get("skip-shared"):
-        shared_created, shared_skipped, shared_warnings, shared_hashes = process_mappings(
-            reg.get_shared_template_dir(),
-            reg.get_shared_template_mappings(),
-            vars_dict,
-            force,
-            update,
-            existing_hashes,
-        )
-
     # Make all shell scripts in scripts/ executable
     scripts_dir = os.path.join(".", "scripts")
     if os.path.isdir(scripts_dir):
@@ -282,16 +242,11 @@ def run_cmd(registry, args, flags):
 
     # Persist file hashes for future --update customization detection
     all_new_hashes = {}
-    all_new_hashes.update(reg_hashes)
-    all_new_hashes.update(shared_hashes)
+    for h in all_hash_dicts:
+        all_new_hashes.update(h)
     existing_hashes.update(all_new_hashes)
     save_hashes(existing_hashes)
 
-    # Merge results
-    created = reg_created + shared_created
-    skipped = reg_skipped + shared_skipped
-    warnings = reg_warnings + shared_warnings
-
     # Print summary
     if created:
         print("Created:")
@@ -314,8 +269,139 @@ def run_cmd(registry, args, flags):
         print("\nNote: Existing CI workflow preserved. Review and merge manually if needed.")
 
     # Next steps
-    steps = NEXT_STEPS.get(registry)
-    if steps:
-        print("\nNext steps:")
-        for i, step in enumerate(steps, 1):
-            print(f"  {i}. {step}")
+    if registry:
+        steps = NEXT_STEPS.get(registry)
+        if steps:
+            print("\nNext steps:")
+            for i, step in enumerate(steps, 1):
+                print(f"  {i}. {step}")
+
+
+def run_cmd(registry, args, flags):
+    """Init command handler.
+
+    Scaffolds release infrastructure (CI, publish workflows, changelog, etc.)
+    from templates.
+    """
+    reg = REGISTRIES[registry]
+
+    # Check that a project file exists
+    if not reg.check_project_exists("."):
+        print(f"Error: no {registry} project found in current directory.", file=sys.stderr)
+        print(reg.get_project_init_hint(), file=sys.stderr)
+        sys.exit(1)
+
+    # Gather template variables
+    vars_dict = reg.get_template_vars(".")
+    from datetime import datetime
+    vars_dict["year"] = str(datetime.now().year)
+
+    force = flags.get("force", False)
+    update = flags.get("update", False)
+
+    existing_hashes = load_hashes()
+
+    # Process registry-specific templates
+    reg_created, reg_skipped, reg_warnings, reg_hashes = process_mappings(
+        reg.get_template_dir(),
+        reg.get_template_mappings(),
+        vars_dict,
+        force,
+        update,
+        existing_hashes,
+    )
+
+    # Process shared templates (skip if another registry already handled them)
+    shared_created, shared_skipped, shared_warnings, shared_hashes = [], [], [], {}
+    if not flags.get("skip-shared"):
+        shared_created, shared_skipped, shared_warnings, shared_hashes = process_mappings(
+            reg.get_shared_template_dir(),
+            reg.get_shared_template_mappings(),
+            vars_dict,
+            force,
+            update,
+            existing_hashes,
+        )
+
+    created = reg_created + shared_created
+    skipped = reg_skipped + shared_skipped
+    warnings = reg_warnings + shared_warnings
+
+    _finalize_scaffold(
+        existing_hashes, [reg_hashes, shared_hashes],
+        created, skipped, warnings, registry=registry,
+    )
+
+
+def run_cmd_multi(registries_list, args, flags):
+    """Scaffold for multiple registries with a merged publish workflow.
+
+    Uses the primary registry for template vars and CI, then writes a merged
+    publish.yml that contains jobs for all detected registries.
+    """
+    primary = registries_list[0]
+    reg = REGISTRIES[primary]
+
+    if not reg.check_project_exists("."):
+        print(f"Error: no {primary} project found in current directory.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Multiple registries detected: {', '.join(registries_list)}")
+    print("Scaffolding with merged publish workflow.")
+
+    vars_dict = reg.get_template_vars(".")
+    from datetime import datetime
+    vars_dict["year"] = str(datetime.now().year)
+
+    force = flags.get("force", False)
+    update = flags.get("update", False)
+    existing_hashes = load_hashes()
+
+    # Process primary registry CI template only (publish will come from merged)
+    ci_mappings = [m for m in reg.get_template_mappings() if "publish" not in m["template"]]
+    ci_created, ci_skipped, ci_warnings, ci_hashes = process_mappings(
+        reg.get_template_dir(),
+        ci_mappings,
+        vars_dict,
+        force,
+        update,
+        existing_hashes,
+    )
+
+    # Process merged publish workflow template
+    merged_tpl_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)),
+                                  "..", "templates", "merged")
+    merged_created, merged_skipped, merged_warnings, merged_hashes = process_mappings(
+        merged_tpl_dir,
+        [{"template": "publish.yml.tpl", "target": ".github/workflows/publish.yml"}],
+        vars_dict,
+        force,
+        update,
+        existing_hashes,
+    )
+
+    # Process shared templates (once)
+    shared_created, shared_skipped, shared_warnings, shared_hashes = process_mappings(
+        reg.get_shared_template_dir(),
+        reg.get_shared_template_mappings(),
+        vars_dict,
+        force,
+        update,
+        existing_hashes,
+    )
+
+    created = ci_created + merged_created + shared_created
+    skipped = ci_skipped + merged_skipped + shared_skipped
+    warnings = ci_warnings + merged_warnings + shared_warnings
+
+    _finalize_scaffold(
+        existing_hashes, [ci_hashes, merged_hashes, shared_hashes],
+        created, skipped, warnings,
+    )
+
+    # Show combined next steps for dual-registry
+    print("\nNext steps:")
+    print("  1. Add an NPM_TOKEN secret to your GitHub repo (Settings > Secrets > Actions)")
+    print("  2. Configure Trusted Publishing on pypi.org")
+    print("  3. Push to GitHub to activate the CI workflow")
+    print("  4. Run rlsbl release [patch|minor|major]")

package/rlsbl/commands/release.py

@@ -127,21 +127,40 @@ def run_cmd(registry, args, flags):
         log("--- No changes made ---")
         return
 
-    # Write new version to the primary registry file
+    # Pre-compute which files will be modified
     version_file = reg.get_version_file()
+    files_to_commit = [version_file]
+    for name, other_reg in REGISTRIES.items():
+        if name == registry:
+            continue
+        if other_reg.check_project_exists("."):
+            files_to_commit.append(other_reg.get_version_file())
+
+    # Confirmation prompt (skip with --yes)
+    if not flags.get("yes"):
+        print(f"\nAbout to release {new_version} ({bump_type}) on {branch}")
+        print(f"  Tag: {tag}")
+        print(f"  Files: {', '.join(files_to_commit)}")
+        try:
+            answer = input("Proceed? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print("\nAborted.")
+            sys.exit(1)
+        if answer != "y":
+            print("Aborted.")
+            sys.exit(0)
+
+    # Write new version to the primary registry file
     reg.write_version(".", new_version)
     log(f"Updated version in {version_file}")
 
     # Sync version to all other recognized version files
-    files_to_commit = [version_file]
     for name, other_reg in REGISTRIES.items():
         if name == registry:
             continue
         if other_reg.check_project_exists("."):
             other_reg.write_version(".", new_version)
-            other_file = other_reg.get_version_file()
-            files_to_commit.append(other_file)
-            log(f"Synced version to {other_file}")
+            log(f"Synced version to {other_reg.get_version_file()}")
 
     # Commit all bumped version files together
     commit_tool = find_commit_tool()

package/rlsbl/commands/undo.py

@@ -0,0 +1,66 @@
+"""Undo command: revert the last release."""
+
+import sys
+
+from ..utils import run, run_silent, check_gh_installed, check_gh_auth
+
+
+def run_cmd(registry, args, flags):
+    check_gh_installed()
+    check_gh_auth()
+
+    # Find the latest tag
+    try:
+        tag = run("git", ["describe", "--tags", "--abbrev=0"])
+    except Exception:
+        print("Error: no tags found. Nothing to undo.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"This will undo release {tag}:")
+    print(f"  - Delete git tag {tag} (local + remote)")
+    print(f"  - Revert the version bump commit")
+    print(f"  - Delete the GitHub Release for {tag}")
+
+    if not flags.get("yes"):
+        try:
+            answer = input("\nThis is destructive. Proceed? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print("\nAborted.")
+            sys.exit(1)
+        if answer != "y":
+            print("Aborted.")
+            sys.exit(0)
+
+    # Delete GitHub Release
+    try:
+        run("gh", ["release", "delete", tag, "--yes"])
+        print(f"Deleted GitHub Release: {tag}")
+    except Exception as e:
+        print(f"Warning: could not delete GitHub Release: {e}")
+
+    # Delete remote tag
+    try:
+        run("git", ["push", "origin", f":{tag}"])
+        print(f"Deleted remote tag: {tag}")
+    except Exception as e:
+        print(f"Warning: could not delete remote tag: {e}")
+
+    # Delete local tag
+    try:
+        run("git", ["tag", "-d", tag])
+        print(f"Deleted local tag: {tag}")
+    except Exception as e:
+        print(f"Warning: could not delete local tag: {e}")
+
+    # Revert the version bump commit (should be HEAD)
+    try:
+        head_msg = run("git", ["log", "-1", "--format=%s"])
+        if head_msg == tag:
+            run("git", ["revert", "--no-edit", "HEAD"])
+            print(f"Reverted commit: {head_msg}")
+        else:
+            print(f"Warning: HEAD commit ({head_msg}) doesn't match tag ({tag}). Skipping revert.")
+    except Exception as e:
+        print(f"Warning: could not revert commit: {e}")
+
+    print(f"\nUndo complete. Run 'git push' to sync the revert.")

package/templates/merged/publish.yml.tpl

@@ -0,0 +1,30 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  npm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+  pypi:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: astral-sh/setup-uv@v7
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

package/templates/shared/CLAUDE.md.tpl

@@ -5,11 +5,11 @@
 This project uses [rlsbl](https://github.com/smm-h/rlsbl) for release orchestration.
 
 - Update CHANGELOG.md with a `## X.Y.Z` entry describing changes
-- Run `rlsbl <registry> release [patch|minor|major]` to bump version and create a GitHub Release
+- Run `rlsbl release [patch|minor|major]` to bump version and create a GitHub Release
 - CI handles publishing automatically via the publish workflow
-- Never publish manually — always use `rlsbl <registry> release`
+- Never publish manually — always use `rlsbl release`
 - Requires `NPM_TOKEN` secret on GitHub (for npm projects)
-- Use `rlsbl <registry> release --dry-run` to preview a release without making changes
+- Use `rlsbl release --dry-run` to preview a release without making changes
 
 ## Conventions