rlsbl 0.8.3 → 0.9.0

package/rlsbl/commands/release.py

@@ -1,287 +0,0 @@
-"""Release command: bump version, commit, push, create GitHub Release."""
-
-import os
-import sys
-import time
-
-from ..config import should_tag
-from ..registries import REGISTRIES
-from ..tagging import ensure_github_topic, ensure_npm_keyword, ensure_pypi_keyword
-from ..utils import (
-    bump_version,
-    check_gh_auth,
-    check_gh_installed,
-    extract_changelog_entry,
-    find_commit_tool,
-    get_current_branch,
-    get_push_timeout,
-    is_clean_tree,
-    push_if_needed,
-    run,
-)
-
-VALID_BUMP_TYPES = ("patch", "minor", "major")
-
-
-def run_cmd(registry, args, flags):
-    """Release command handler.
-
-    Bumps version, commits, pushes, and creates a GitHub Release.
-    """
-    quiet = flags.get("quiet", False)
-
-    def log(msg):
-        if not quiet:
-            print(msg)
-
-    reg = REGISTRIES[registry]
-
-    # Check prerequisites
-    if not check_gh_installed():
-        print("Error: gh CLI is not installed. Install it from https://cli.github.com", file=sys.stderr)
-        sys.exit(1)
-    if not check_gh_auth():
-        print('Error: gh CLI is not authenticated. Run "gh auth login" first.', file=sys.stderr)
-        sys.exit(1)
-
-    # Clean working tree
-    if not is_clean_tree():
-        print("Error: working tree is not clean. Commit your changes first.", file=sys.stderr)
-        sys.exit(1)
-
-    # Branch check
-    branch = get_current_branch()
-    if branch not in ("main", "master"):
-        print(f'Warning: you are on branch "{branch}", not main/master.', file=sys.stderr)
-
-    # Current version
-    current_version = reg.read_version(".")
-    log(f"Current version: {current_version}")
-
-    # If the current version has never been tagged, release it as-is (bootstrap)
-    current_tag = f"v{current_version}"
-    current_tag_exists = len(run("git", ["tag", "-l", current_tag])) > 0
-
-    if not current_tag_exists:
-        new_version = current_version
-        bump_type = None
-        tag = current_tag
-        if args:
-            log(f"First release: releasing {new_version} as-is (bump type ignored)")
-        else:
-            log(f"First release: {new_version}")
-    else:
-        bump_type = args[0] if args else "patch"
-        if bump_type not in VALID_BUMP_TYPES:
-            print(
-                f'Error: invalid bump type "{bump_type}". Use: {", ".join(VALID_BUMP_TYPES)}',
-                file=sys.stderr,
-            )
-            sys.exit(1)
-
-        new_version = bump_version(current_version, bump_type)
-        tag = f"v{new_version}"
-        log(f"New version: {new_version} ({bump_type})")
-
-    # Check tag doesn't already exist
-    tag_output = run("git", ["tag", "-l", tag])
-    if len(tag_output) > 0:
-        print(f'Error: tag "{tag}" already exists.', file=sys.stderr)
-        sys.exit(1)
-
-    # Validate changelog entry
-    changelog_path = os.path.join(".", "CHANGELOG.md")
-    if not os.path.exists(changelog_path):
-        print(
-            f"Error: CHANGELOG.md not found. Create one with a ## {new_version} section.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-    changelog_entry = extract_changelog_entry(changelog_path, new_version)
-    if not changelog_entry:
-        print(
-            f"Error: no changelog entry found for version {new_version} in CHANGELOG.md.",
-            file=sys.stderr,
-        )
-        print(f'Add a "## {new_version}" section describing the changes.', file=sys.stderr)
-        sys.exit(1)
-    if len(changelog_entry.strip()) < 10:
-        print(
-            f"Warning: changelog entry for {new_version} is very short. Consider adding more detail.",
-            file=sys.stderr,
-        )
-
-    # Run pre-release hook if present
-    pre_release_script = os.path.join(".", ".rlsbl", "hooks", "pre-release.sh")
-    if os.path.exists(pre_release_script):
-        log("Running pre-release hook...")
-        try:
-            run("bash", [pre_release_script])
-        except Exception:
-            print("Error: pre-release hook failed. Fix the issues and try again.", file=sys.stderr)
-            sys.exit(1)
-
-    # Dry run: print summary and return
-    if flags.get("dry-run", False):
-        log("\n--- Dry run summary ---")
-        log(f"Registry:  {registry}")
-        if bump_type:
-            log(f"Bump:      {current_version} -> {new_version} ({bump_type})")
-        else:
-            log(f"Version:   {new_version} (first release)")
-        log(f"Tag:       {tag}")
-        log(f"Branch:    {branch}")
-        # Show other version files that would be synced
-        other_files = []
-        for name, other_reg in REGISTRIES.items():
-            if name == registry:
-                continue
-            if other_reg.check_project_exists("."):
-                other_file = other_reg.get_version_file()
-                if other_file:
-                    other_files.append(other_file)
-        if other_files:
-            log(f"Sync to:   {', '.join(other_files)}")
-        log(f"Changelog:\n{changelog_entry}")
-        log("--- No changes made ---")
-        return
-
-    # Pre-compute which files will be modified
-    version_file = reg.get_version_file()
-    files_to_commit = []
-    if version_file:
-        files_to_commit.append(version_file)
-    for name, other_reg in REGISTRIES.items():
-        if name == registry:
-            continue
-        if other_reg.check_project_exists("."):
-            other_file = other_reg.get_version_file()
-            if other_file:
-                files_to_commit.append(other_file)
-
-    # Confirmation prompt (skip with --yes)
-    if not flags.get("yes"):
-        bump_label = f" ({bump_type})" if bump_type else ""
-        print(f"\nAbout to release {new_version}{bump_label} on {branch}")
-        print(f"  Tag: {tag}")
-        if files_to_commit:
-            print(f"  Files: {', '.join(files_to_commit)}")
-        else:
-            print("  Files: (none -- version is the git tag)")
-        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 version files (skip if version didn't change, e.g. first release)
-    if new_version != current_version:
-        if version_file:
-            reg.write_version(".", new_version)
-            log(f"Updated version in {version_file}")
-
-        # Sync version to all other recognized version files
-        for name, other_reg in REGISTRIES.items():
-            if name == registry:
-                continue
-            if other_reg.check_project_exists("."):
-                other_file = other_reg.get_version_file()
-                if other_file:
-                    other_reg.write_version(".", new_version)
-                    log(f"Synced version to {other_file}")
-
-    # Ecosystem tagging: add keyword to manifests if enabled (after confirmation)
-    if should_tag(flags):
-        try:
-            if REGISTRIES["npm"].check_project_exists("."):
-                if ensure_npm_keyword(".", quiet=quiet):
-                    if "package.json" not in files_to_commit:
-                        files_to_commit.append("package.json")
-        except Exception:
-            pass
-        try:
-            if REGISTRIES["pypi"].check_project_exists("."):
-                if ensure_pypi_keyword(".", quiet=quiet):
-                    if "pyproject.toml" not in files_to_commit:
-                        files_to_commit.append("pyproject.toml")
-        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:
-        commit_tool = find_commit_tool()
-        if commit_tool == "safegit":
-            run(commit_tool, ["commit", "-m", tag, "--", *files_to_commit])
-        else:
-            run("git", ["add", *files_to_commit])
-            run("git", ["commit", "-m", tag])
-        log(f"Committed: {tag}")
-    elif not needs_commit:
-        log("No changes to commit")
-
-    # Create local git tag
-    run("git", ["tag", tag])
-    log(f"Tagged: {tag}")
-
-    # Push commits and tag
-    push_timeout = get_push_timeout()
-    if push_timeout != 120:
-        log(f"Push timeout: {push_timeout}s (from RLSBL_PUSH_TIMEOUT)")
-    push_if_needed(branch)
-    run("git", ["push", "origin", tag], timeout=push_timeout)
-    log(f"Pushed to origin/{branch}")
-
-    # Create GitHub Release using a temp notes file
-    notes_file = f".rlsbl-notes-{int(time.time() * 1000)}.tmp"
-    writing_file = notes_file + ".writing"
-    try:
-        with open(writing_file, "w", encoding="utf-8") as f:
-            f.write(changelog_entry)
-        os.rename(writing_file, notes_file)
-        run("gh", ["release", "create", tag, "--title", tag, "--notes-file", notes_file])
-        log(f"Created GitHub Release: {tag}")
-    finally:
-        # Clean up temp files even if gh release fails
-        for tmp in (notes_file, writing_file):
-            if os.path.exists(tmp):
-                os.unlink(tmp)
-
-    # Ecosystem tagging: add GitHub topic after release is created
-    if should_tag(flags):
-        ensure_github_topic(quiet=quiet)
-
-    # Run post-release hook if present (non-fatal: release is already complete)
-    post_release_script = os.path.join(".", ".rlsbl", "hooks", "post-release.sh")
-    if os.path.exists(post_release_script):
-        log("Running post-release hook...")
-        try:
-            env = os.environ.copy()
-            env["RLSBL_VERSION"] = new_version
-            run("bash", [post_release_script], env=env)
-        except Exception as e:
-            print(f"Warning: post-release hook failed: {e}", file=sys.stderr)
-
-    # Hint: how to watch CI for this release
-    try:
-        commit_sha = run("git", ["rev-parse", "HEAD"])
-        log(f"Watch CI: rlsbl watch {commit_sha}")
-    except Exception:
-        pass
-
-    log(f"\nRelease {new_version} complete!")

package/rlsbl/commands/status.py

@@ -1,76 +0,0 @@
-"""Status command: show project status summary."""
-
-import os
-import sys
-
-from ..registries import REGISTRIES
-from ..utils import (
-    extract_changelog_entry,
-    get_current_branch,
-    is_clean_tree,
-    run,
-)
-
-
-def run_cmd(registry, args, flags):
-    """Status command handler.
-
-    Shows a quick 'where am I' summary: package info, git state, changelog, CI.
-    """
-    reg = REGISTRIES[registry]
-
-    if not reg.check_project_exists("."):
-        print(f"No {registry} project found in current directory.", file=sys.stderr)
-        sys.exit(1)
-
-    version = reg.read_version(".")
-    vars_dict = reg.get_template_vars(".")
-    name = vars_dict.get("name") or "(unknown)"
-
-    print(f"Package:   {name}")
-
-    # Show version info for all detected registries
-    for r_name, r_mod in REGISTRIES.items():
-        if r_mod.check_project_exists("."):
-            ver = r_mod.read_version(".")
-            file = r_mod.get_version_file() or "git tag"
-            print(f"Version:   {ver} ({r_name}, {file})")
-
-    # Git info
-    try:
-        branch = get_current_branch()
-        print(f"Branch:    {branch}")
-    except Exception:
-        print("Branch:    (not a git repo)")
-
-    # Last tag
-    try:
-        last_tag = run("git", ["describe", "--tags", "--abbrev=0"])
-        print(f"Last tag:  {last_tag}")
-    except Exception:
-        print("Last tag:  (none)")
-
-    # Clean tree
-    try:
-        print(f"Clean:     {'yes' if is_clean_tree() else 'no'}")
-    except Exception:
-        print("Clean:     (unknown)")
-
-    # Changelog
-    changelog_path = "CHANGELOG.md"
-    if os.path.exists(changelog_path):
-        entry = extract_changelog_entry(changelog_path, version)
-        if entry:
-            print(f"Changelog: has entry for {version}")
-        else:
-            print(f"Changelog: no entry for {version}")
-    else:
-        print("Changelog: (not found)")
-
-    # CI workflows
-    ci_exists = os.path.exists(".github/workflows/ci.yml")
-    publish_exists = os.path.exists(".github/workflows/publish.yml") or os.path.exists(
-        ".github/workflows/workflow.yml"
-    )
-    print(f"CI:        {'yes' if ci_exists else 'missing'}")
-    print(f"Publish:   {'yes' if publish_exists else 'missing'}")

package/rlsbl/commands/undo.py

@@ -1,74 +0,0 @@
-"""Undo command: revert the last release."""
-
-import sys
-
-from ..utils import run, check_gh_installed, check_gh_auth, get_push_timeout, is_clean_tree
-
-
-def run_cmd(registry, args, flags):
-    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:
-        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}"], timeout=get_push_timeout())
-        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/rlsbl/commands/watch.py

@@ -1,125 +0,0 @@
-"""Watch command: monitor CI runs for a commit and report results."""
-
-import json
-import shutil
-import subprocess
-import sys
-import time
-
-from ..utils import run
-
-
-def _notify(title, body):
-    """Send a desktop notification. Non-fatal if unavailable."""
-    try:
-        if sys.platform == "darwin":
-            # Escape double quotes to prevent AppleScript injection
-            escaped_title = title.replace('"', '\\"')
-            escaped_body = body.replace('"', '\\"')
-            subprocess.run(
-                ["osascript", "-e",
-                 f'display notification "{escaped_body}" with title "{escaped_title}"'],
-                timeout=5, capture_output=True,
-            )
-        elif shutil.which("notify-send"):
-            subprocess.run(
-                ["notify-send", "-u", "normal", title, body],
-                timeout=5, capture_output=True,
-            )
-    except Exception:
-        pass
-
-
-def run_cmd(registry, args, flags):
-    """Watch all CI runs for a commit until they complete.
-
-    Usage: rlsbl watch [<commit-sha>]
-    Defaults to HEAD if no commit SHA is provided.
-    """
-    try:
-        # Get commit SHA (resolve short SHAs -- gh requires full 40-char)
-        if args:
-            try:
-                commit_sha = run("git", ["rev-parse", args[0]])
-            except Exception:
-                commit_sha = args[0]
-        else:
-            try:
-                commit_sha = run("git", ["rev-parse", "HEAD"])
-            except Exception:
-                print("Error: not a git repository and no commit SHA provided.", file=sys.stderr)
-                sys.exit(1)
-
-        # Get repo info for display and URLs
-        try:
-            repo_info = run("gh", ["repo", "view", "--json", "nameWithOwner,name"])
-            info = json.loads(repo_info)
-            repo_slug = info.get("nameWithOwner", "")
-            repo_name = info.get("name", "")
-        except Exception:
-            print("Error: could not get repo info. Is gh installed and authenticated?", file=sys.stderr)
-            sys.exit(1)
-
-        # Try to find a tag for this commit for nicer display
-        try:
-            tag = run("git", ["describe", "--tags", "--exact-match", commit_sha])
-        except Exception:
-            tag = commit_sha[:12]
-
-        label = f"{repo_name} {tag}" if repo_name else tag
-
-        # Poll until at least one run appears (retry up to 30s)
-        runs = []
-        for _ in range(15):
-            try:
-                raw = run("gh", ["run", "list", "--commit", commit_sha,
-                                 "--json", "databaseId,name,status"])
-                parsed = json.loads(raw)
-                if parsed:
-                    runs = parsed
-                    break
-            except Exception:
-                pass
-            time.sleep(2)
-
-        if not runs:
-            print(f"rlsbl: {label}: no CI runs found after 30s", file=sys.stderr)
-            sys.exit(1)
-
-        print(f"rlsbl: {label}: found {len(runs)} CI run(s), watching...", file=sys.stderr)
-
-        # Watch each run sequentially, collecting results
-        any_failed = False
-        for ci_run in runs:
-            run_id = str(ci_run["databaseId"])
-            workflow_name = ci_run.get("name", f"run {run_id}")
-
-            try:
-                # gh run watch blocks until the run completes;
-                # --exit-status makes it exit 1 on failure; check=True raises
-                # CalledProcessError so we can distinguish pass from fail
-                subprocess.run(
-                    ["gh", "run", "watch", run_id, "--exit-status"],
-                    capture_output=True, text=True, timeout=3600, check=True,
-                )
-                print(f"rlsbl: {label}: {workflow_name} passed", file=sys.stderr)
-            except subprocess.CalledProcessError:
-                any_failed = True
-                print(f"rlsbl: {label}: {workflow_name} FAILED", file=sys.stderr)
-                if repo_slug:
-                    print(f"rlsbl: https://github.com/{repo_slug}/actions/runs/{run_id}",
-                          file=sys.stderr)
-            except subprocess.TimeoutExpired:
-                any_failed = True
-                print(f"rlsbl: {label}: {workflow_name} timed out after 1h", file=sys.stderr)
-
-        # Desktop notification for overall result
-        if any_failed:
-            _notify(f"{label}: CI FAILED", "One or more workflows failed")
-        else:
-            _notify(f"{label}: CI passed", "All workflows passed")
-
-        sys.exit(1 if any_failed else 0)
-    except KeyboardInterrupt:
-        print("\nWatch cancelled.", file=sys.stderr)
-        sys.exit(130)

package/rlsbl/config.py

@@ -1,57 +0,0 @@
-"""Config reading for the tag feature (ecosystem discoverability).
-
-Precedence (highest to lowest):
-  1. CLI flag (--no-tag)
-  2. Project-level: .rlsbl/config.json
-  3. User-level: ~/.rlsbl/config.json
-  4. Default: True (tagging enabled)
-"""
-
-import json
-import os
-
-
-def _project_config():
-    """Resolve project config path at call time (respects cwd changes)."""
-    return os.path.join(".rlsbl", "config.json")
-
-USER_CONFIG = os.path.expanduser("~/.rlsbl/config.json")
-
-
-def read_json_config(path):
-    """Safely read a JSON file, returning {} on missing or malformed."""
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except (OSError, json.JSONDecodeError):
-        return {}
-
-
-def should_tag(flags):
-    """Returns True if tagging is enabled, checking flag > project > user > default."""
-    # CLI flag takes highest precedence
-    if flags.get("no-tag"):
-        return False
-
-    # Project-level config
-    project = read_json_config(_project_config())
-    if "tag" in project:
-        return bool(project["tag"])
-
-    # User-level config
-    user = read_json_config(USER_CONFIG)
-    if "tag" in user:
-        return bool(user["tag"])
-
-    # Default: tagging enabled
-    return True
-
-
-def write_project_config(key, value):
-    """Write or update a key in .rlsbl/config.json (creates dir if needed)."""
-    os.makedirs(os.path.dirname(_project_config()), exist_ok=True)
-    existing = read_json_config(_project_config())
-    existing[key] = value
-    with open(_project_config(), "w", encoding="utf-8") as f:
-        json.dump(existing, f, indent=2)
-        f.write("\n")

package/rlsbl/registries/__init__.py

@@ -1,5 +0,0 @@
-"""Registry lookup for rlsbl."""
-
-from . import go, npm, pypi
-
-REGISTRIES = {"npm": npm, "pypi": pypi, "go": go}