rlsbl 0.5.0 → 0.5.1

package/README.md

@@ -62,7 +62,7 @@ rlsbl release major --dry-run --registry npm
 
 The version is synced across all detected project files (`package.json`, `pyproject.toml`, `VERSION`) regardless of which registry is primary. Go projects use a plain `VERSION` file as the version source.
 
-If `scripts/pre-release.sh` exists, it runs before any changes are made. A non-zero exit aborts the release.
+If `scripts/pre-release.sh` exists, it runs before any changes are made. A non-zero exit aborts the release. If `scripts/post-release.sh` exists, it runs after the release completes (non-fatal). See [Release flow](#release-flow) for details.
 
 ### status
 
@@ -127,6 +127,8 @@ When you run `release`, the following happens in order:
 10. Pushes the branch to `origin`
 11. Creates a GitHub Release tagged `v<new-version>` with the changelog entry as notes
 12. The GitHub Release triggers `publish.yml`, which publishes to the registry
+13. Runs `scripts/post-release.sh` if present (non-fatal -- the release is already complete). The `RLSBL_VERSION` env var is set to the released version. Useful for local install (`go install ./cmd/myapp/`), deploy, or notifications.
+14. Spawns a background process that watches CI via `gh run watch`. When CI finishes, it prints the result to stderr (so AI agents can read it) and sends a desktop notification (`notify-send` on Linux, `osascript` on macOS). On CI failure, it also prints the GitHub Actions run URL. This happens automatically -- no configuration needed.
 
 ## What scaffold creates
 
@@ -141,11 +143,14 @@ When you run `release`, the following happens in order:
 | `.claude/settings.json` | Shared | Claude Code settings |
 | `scripts/check-prs.sh` | Shared | PR review helper |
 | `scripts/pre-release.sh` | Shared | Pre-release hook (runs before each release) |
+| `scripts/post-release.sh` | Shared | Post-release hook (runs after each release, non-fatal) |
 | `scripts/record-gif.sh` | Shared | Terminal recording helper |
 | `scripts/pre-push-hook.sh` | Shared | Pre-push changelog enforcement |
 
 All `.sh` files in `scripts/` are made executable automatically. The pre-push hook is installed into `.git/hooks/pre-push` during scaffold.
 
+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`.
+
 ## Pre-push hook
 
 The scaffolded `scripts/pre-push-hook.sh` is installed as a git pre-push hook during `scaffold`. It prevents pushing when `CHANGELOG.md` lacks an entry for the current version.
@@ -180,6 +185,7 @@ After configuration, all subsequent releases are handled by CI when `rlsbl relea
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `RLSBL_PUSH_TIMEOUT` | `120` | Timeout in seconds for `git push` operations. Increase if your pre-push hooks (e.g. test suites) take longer than 2 minutes. |
+| `RLSBL_VERSION` | -- | Set automatically when running `scripts/post-release.sh`. Contains the just-released version string. |
 
 ## Requirements
 

package/package.json

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

package/rlsbl/utils.py

@@ -109,27 +109,42 @@ def find_commit_tool():
 
 
 def spawn_ci_watcher(commit_sha, tag):
-    """Spawn a detached background process that watches CI and sends a desktop notification."""
+    """Spawn a detached background process that watches CI and prints results to stderr.
+
+    The spawned process inherits the parent's stderr so output appears in the
+    same terminal/stream -- important for AI agents that read stderr.
+    Desktop notifications are sent as a secondary channel when available.
+    """
+    repo_slug = ""
+    try:
+        repo_slug = run("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"])
+    except Exception:
+        pass
+
     repo_name = ""
     try:
         repo_name = run("gh", ["repo", "view", "--json", "name", "-q", ".name"])
     except Exception:
         pass
 
-    notify_cmd = _notify_command()
-    if not notify_cmd:
-        return
-
     label = f"{repo_name} {tag}" if repo_name else tag
 
+    # Build the notification snippet based on what's available on this platform
+    notify_snippet = _notify_snippet()
+
     script = f"""
 import subprocess, sys, time
 
+commit_sha = {commit_sha!r}
+label = {label!r}
+repo_slug = {repo_slug!r}
+
+# Find the CI run by commit SHA (retry up to 30s)
 run_id = None
 for _ in range(15):
     try:
         r = subprocess.run(
-            ["gh", "run", "list", "--commit", "{commit_sha}", "--limit", "1",
+            ["gh", "run", "list", "--commit", commit_sha, "--limit", "1",
              "--json", "databaseId", "-q", ".[0].databaseId"],
             capture_output=True, text=True, timeout=10)
         if r.returncode == 0 and r.stdout.strip():
@@ -142,43 +157,61 @@ for _ in range(15):
 if not run_id:
     sys.exit(0)
 
+# Watch the run until it completes
 result = subprocess.run(
     ["gh", "run", "watch", run_id, "--exit-status"],
     capture_output=True, text=True, timeout=3600)
 
+ok = result.returncode == 0
+
+# Extract last non-empty line as summary for desktop notification
 summary = ""
 for line in reversed(result.stdout.strip().splitlines()):
     if line.strip():
         summary = line.strip()
         break
 
-ok = result.returncode == 0
-title = "{label}: CI passed" if ok else "{label}: CI FAILED"
-{notify_cmd}
+# Print result to stderr so AI agents and terminal users can see it
+if ok:
+    print(f"rlsbl: {{label}}: CI passed", file=sys.stderr)
+else:
+    print(f"rlsbl: {{label}}: CI FAILED", file=sys.stderr)
+    if repo_slug and run_id:
+        print(f"rlsbl: https://github.com/{{repo_slug}}/actions/runs/{{run_id}}", file=sys.stderr)
+
+# Desktop notification (optional, non-fatal)
+title = f"{{label}}: CI passed" if ok else f"{{label}}: CI FAILED"
+try:
+{notify_snippet}
+except Exception:
+    pass
 """
     subprocess.Popen(
         [sys.executable, "-c", script],
         start_new_session=True,
         stdin=subprocess.DEVNULL,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
     )
 
 
-def _notify_command():
-    """Return a Python code snippet for sending a desktop notification, or None."""
+def _notify_snippet():
+    """Return an indented Python code snippet for sending a desktop notification.
+
+    Returns a pass statement if no notification tool is available.
+    The snippet is intended to be embedded inside a try/except block.
+    """
+    indent = "    "
     if sys.platform == "darwin":
         return (
-            'subprocess.run(["osascript", "-e",'
-            ' f\'display notification "{summary}" with title "{title}"\'],'
-            ' timeout=5)'
+            f'{indent}subprocess.run(["osascript", "-e",\n'
+            f'{indent}    f\'display notification "{{summary}}" with title "{{title}}"\'],\n'
+            f'{indent}    timeout=5)'
         )
     if shutil.which("notify-send"):
         return (
-            'urgency = "normal" if ok else "critical"\n'
-            'subprocess.run(["notify-send", "-u", urgency, title, summary], timeout=5)'
+            f'{indent}urgency = "normal" if ok else "critical"\n'
+            f'{indent}subprocess.run(["notify-send", "-u", urgency, title, summary], timeout=5)'
         )
-    return None
+    return f"{indent}pass"
 
 
 def bump_version(version, bump_type):