rlsbl 0.8.2 → 0.9.0

package/rlsbl/registries/go.py

@@ -1,123 +0,0 @@
-"""Go registry adapter for rlsbl.
-
-Go projects use a VERSION file as the source of truth for rlsbl. GoReleaser
-handles the build/publish step triggered by the GitHub Release that rlsbl creates.
-"""
-
-import os
-import re
-
-from ..utils import run
-
-NAME = "go"
-
-VERSION_FILE = "VERSION"
-
-
-def read_version(dir_path):
-    """Read version from the VERSION file."""
-    version_path = os.path.join(dir_path, VERSION_FILE)
-    if not os.path.exists(version_path):
-        raise FileNotFoundError(f"No {VERSION_FILE} file found. Run 'rlsbl scaffold' first.")
-    with open(version_path, "r", encoding="utf-8") as f:
-        return f.read().strip()
-
-
-def write_version(dir_path, version):
-    """Write the new version to the VERSION file."""
-    version_path = os.path.join(dir_path, VERSION_FILE)
-    tmp_path = version_path + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        f.write(version + "\n")
-    os.replace(tmp_path, version_path)
-
-
-def get_version_file():
-    """Returns the filename that holds the version for this registry."""
-    return VERSION_FILE
-
-
-def get_template_dir():
-    """Returns path to the go-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "go")
-
-
-def get_shared_template_dir():
-    """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
-
-
-def get_template_vars(dir_path):
-    """Extract template variables from go.mod."""
-    mod_path = os.path.join(dir_path, "go.mod")
-    name = ""
-    if os.path.exists(mod_path):
-        with open(mod_path) as f:
-            content = f.read()
-        match = re.search(r"^module\s+(\S+)", content, re.MULTILINE)
-        if match:
-            name = match.group(1)
-
-    # Derive short name from module path (last segment)
-    short_name = name.rsplit("/", 1)[-1] if "/" in name else name
-
-    # Derive repo name from module path (e.g. "github.com/user/repo")
-    repo_name = ""
-    repo_match = re.search(r"github\.com/([^/\s]+/[^/\s]+)", name)
-    if repo_match:
-        repo_name = repo_match.group(1)
-
-    # Author from git config
-    author = ""
-    try:
-        author = run("git", ["config", "user.name"])
-    except Exception:
-        pass
-
-    try:
-        version = read_version(dir_path)
-    except FileNotFoundError:
-        version = "0.0.0"
-
-    return {
-        "name": short_name,
-        "modulePath": name,
-        "version": version,
-        "author": author,
-        "repoName": repo_name,
-        "binCommand": short_name,
-        "publishSetup": "GoReleaser handles binary publishing via GitHub Actions (no secrets needed)",
-    }
-
-
-def get_template_mappings():
-    """Returns go-specific template mappings (template file -> target path)."""
-    return [
-        {"template": "VERSION.tpl", "target": "VERSION"},
-        {"template": "ci.yml.tpl", "target": ".github/workflows/ci.yml"},
-        {"template": "publish.yml.tpl", "target": ".github/workflows/publish.yml"},
-        {"template": "goreleaser.yml.tpl", "target": ".goreleaser.yml"},
-    ]
-
-
-def get_shared_template_mappings():
-    """Returns shared template mappings."""
-    return [
-        {"template": "CHANGELOG.md.tpl", "target": "CHANGELOG.md"},
-        {"template": "gitignore.tpl", "target": ".gitignore"},
-        {"template": "LICENSE.tpl", "target": "LICENSE"},
-        {"template": "CLAUDE.md.tpl", "target": "CLAUDE.md"},
-        {"template": "claude-settings.json.tpl", "target": ".claude/settings.json"},
-        {"template": "hooks/pre-release.sh.tpl", "target": ".rlsbl/hooks/pre-release.sh"},
-        {"template": "hooks/post-release.sh.tpl", "target": ".rlsbl/hooks/post-release.sh"},
-    ]
-
-
-def check_project_exists(dir_path):
-    """Returns True if a go.mod exists in the given directory."""
-    return os.path.exists(os.path.join(dir_path, "go.mod"))
-
-
-def get_project_init_hint():
-    """Hint for users who haven't initialized their project yet."""
-    return 'Run "go mod init <module-path>" first'

package/rlsbl/registries/npm.py

@@ -1,119 +0,0 @@
-"""npm registry adapter for rlsbl."""
-
-import json
-import os
-import re
-
-NAME = "npm"
-
-
-def read_version(dir_path):
-    """Read the version from package.json in the given directory."""
-    pkg_path = os.path.join(dir_path, "package.json")
-    with open(pkg_path, "r", encoding="utf-8") as f:
-        pkg = json.load(f)
-    if "version" not in pkg:
-        raise ValueError(f"No 'version' field in {pkg_path}")
-    return pkg["version"]
-
-
-def write_version(dir_path, version):
-    """Write a new version to package.json, preserving formatting."""
-    pkg_path = os.path.join(dir_path, "package.json")
-    with open(pkg_path, "r", encoding="utf-8") as f:
-        raw = f.read()
-
-    # Detect indent: look for the first indented line
-    indent_match = re.search(r'^( +|\t+)"', raw, re.MULTILINE)
-    indent = indent_match.group(1) if indent_match else "  "
-
-    pkg = json.loads(raw)
-    pkg["version"] = version
-
-    # Preserve trailing newline if present
-    trailing_newline = "\n" if raw.endswith("\n") else ""
-    output = json.dumps(pkg, indent=indent, ensure_ascii=False) + trailing_newline
-    # Atomic write: write to temp file, then rename
-    tmp_path = pkg_path + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        f.write(output)
-    os.replace(tmp_path, pkg_path)
-
-
-def get_version_file():
-    """Returns the filename that holds the version for this registry."""
-    return "package.json"
-
-
-def get_template_dir():
-    """Returns path to the npm-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "npm")
-
-
-def get_shared_template_dir():
-    """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
-
-
-def get_template_vars(dir_path):
-    """Extract template variables from the target project's package.json."""
-    pkg_path = os.path.join(dir_path, "package.json")
-    with open(pkg_path, "r", encoding="utf-8") as f:
-        pkg = json.load(f)
-
-    # Derive binCommand from the bin field (first key if object, or package name)
-    bin_command = pkg.get("name", "")
-    bin_field = pkg.get("bin")
-    if isinstance(bin_field, dict) and bin_field:
-        bin_command = next(iter(bin_field))
-    elif isinstance(bin_field, str):
-        bin_command = pkg.get("name", "")
-
-    # Derive repoName from repository field
-    repo_name = ""
-    repository = pkg.get("repository")
-    if repository:
-        url = repository if isinstance(repository, str) else (repository.get("url") or "")
-        match = re.search(r"github\.com[/:]([^/]+/[^/.]+)", url)
-        if match:
-            repo_name = match.group(1)
-
-    return {
-        "name": pkg.get("name", ""),
-        "version": pkg.get("version", "0.1.0"),
-        "binCommand": bin_command,
-        "author": pkg.get("author", ""),
-        "repoName": repo_name,
-        "publishSetup": "Requires NPM_TOKEN secret on GitHub (Settings > Secrets > Actions)",
-    }
-
-
-def get_template_mappings():
-    """Returns npm-specific template mappings (template file -> target path)."""
-    return [
-        {"template": "ci.yml.tpl", "target": ".github/workflows/ci.yml"},
-        {"template": "publish.yml.tpl", "target": ".github/workflows/publish.yml"},
-    ]
-
-
-def get_shared_template_mappings():
-    """Returns shared template mappings."""
-    return [
-        {"template": "CHANGELOG.md.tpl", "target": "CHANGELOG.md"},
-        {"template": "gitignore.tpl", "target": ".gitignore"},
-        {"template": "LICENSE.tpl", "target": "LICENSE"},
-        {"template": "CLAUDE.md.tpl", "target": "CLAUDE.md"},
-        {"template": "hooks/pre-release.sh.tpl", "target": ".rlsbl/hooks/pre-release.sh"},
-        {"template": "hooks/post-release.sh.tpl", "target": ".rlsbl/hooks/post-release.sh"},
-        {"template": "claude-settings.json.tpl", "target": ".claude/settings.json"},
-    ]
-
-
-def check_project_exists(dir_path):
-    """Returns True if a package.json exists in the given directory."""
-    return os.path.exists(os.path.join(dir_path, "package.json"))
-
-
-def get_project_init_hint():
-    """Hint for users who haven't initialized their project yet."""
-    return 'Run "npm init" first'

package/rlsbl/registries/pypi.py

@@ -1,171 +0,0 @@
-"""PyPI registry adapter for rlsbl."""
-
-import os
-import re
-import tomllib
-
-from ..utils import run
-
-NAME = "pypi"
-
-
-def read_version(dir_path):
-    """Read the version from pyproject.toml in the given directory."""
-    toml_path = os.path.join(dir_path, "pyproject.toml")
-    with open(toml_path, "rb") as f:
-        data = tomllib.load(f)
-    try:
-        return data["project"]["version"]
-    except KeyError:
-        raise ValueError(f"No [project].version in {toml_path}")
-
-
-def write_version(dir_path, version):
-    """Write a new version to pyproject.toml using regex replacement.
-
-    tomllib is read-only (no stdlib TOML writer), so we use a regex to
-    replace the version string within the [project] section only,
-    preserving all other formatting.
-    """
-    toml_path = os.path.join(dir_path, "pyproject.toml")
-    with open(toml_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    # Find [project] section boundaries to avoid matching version keys
-    # in other sections (e.g. [tool.something])
-    project_match = re.search(r"^\[project\]\s*$", content, re.MULTILINE)
-    if not project_match:
-        raise ValueError("No [project] section found in pyproject.toml")
-
-    section_start = project_match.end()
-    # Find next top-level section header or EOF
-    next_section = re.search(r"^\[", content[section_start:], re.MULTILINE)
-    section_end = section_start + next_section.start() if next_section else len(content)
-
-    # Replace version only within [project] section
-    section = content[section_start:section_end]
-    updated_section = re.sub(
-        r'^(version\s*=\s*)"[^"]+"',
-        rf'\g<1>"{version}"',
-        section,
-        count=1,
-        flags=re.MULTILINE,
-    )
-    updated = content[:section_start] + updated_section + content[section_end:]
-
-    # Atomic write: write to temp file, then rename
-    tmp_path = toml_path + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        f.write(updated)
-    os.replace(tmp_path, toml_path)
-
-
-def get_version_file():
-    """Returns the filename that holds the version for this registry."""
-    return "pyproject.toml"
-
-
-def get_template_dir():
-    """Returns path to the pypi-specific template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "pypi")
-
-
-def get_shared_template_dir():
-    """Returns path to the shared template directory."""
-    return os.path.join(os.path.dirname(__file__), "..", "templates", "shared")
-
-
-def get_template_vars(dir_path):
-    """Extract template variables from the target project's pyproject.toml."""
-    toml_path = os.path.join(dir_path, "pyproject.toml")
-    with open(toml_path, "rb") as f:
-        data = tomllib.load(f)
-
-    project = data.get("project", {})
-    name = project.get("name", "")
-    version = project.get("version", "0.1.0")
-
-    # Extract author -- fall back to git config
-    author = ""
-    try:
-        author = run("git", ["config", "user.name"])
-    except Exception:
-        pass
-
-    # Extract repo name from project.urls
-    repo_name = ""
-    urls = project.get("urls", {})
-    for url in urls.values():
-        match = re.search(r"github\.com/([^/\s\"]+/[^/\s\"]+)", url)
-        if match:
-            repo_name = match.group(1).removesuffix(".git")
-            break
-
-    # Derive binCommand from project.scripts (CLI entry points)
-    bin_command = ""
-    scripts = project.get("scripts", {})
-    if scripts:
-        bin_command = next(iter(scripts))  # first script entry
-
-    # Derive the actual Python import name.
-    # 1) Check hatch build config for an explicit packages list.
-    import_name = None
-    hatch = data.get("tool", {}).get("hatch", {})
-    packages = (
-        hatch.get("build", {}).get("targets", {}).get("wheel", {}).get("packages")
-    )
-    if packages and isinstance(packages, list) and len(packages) > 0:
-        # Strip src/ prefix (common hatch src layout) and convert path to module name
-        first_pkg = packages[0]
-        import_name = first_pkg.removeprefix("src/").replace("/", ".")
-
-    # 2) Fall back to filesystem detection, then underscore convention.
-    if not import_name:
-        underscored = name.replace("-", "_")
-        if os.path.isdir(os.path.join(dir_path, underscored)):
-            import_name = underscored
-        elif os.path.isdir(os.path.join(dir_path, name)):
-            import_name = name
-        else:
-            import_name = underscored  # fallback to convention
-
-    return {
-        "name": name,
-        "version": version,
-        "binCommand": bin_command,
-        "author": author,
-        "repoName": repo_name,
-        "importName": import_name,
-        "publishSetup": "Configure Trusted Publishing on pypi.org for automated PyPI releases",
-    }
-
-
-def get_template_mappings():
-    """Returns pypi-specific template mappings (template file -> target path)."""
-    return [
-        {"template": "ci.yml.tpl", "target": ".github/workflows/ci.yml"},
-        {"template": "publish.yml.tpl", "target": ".github/workflows/publish.yml"},
-    ]
-
-
-def get_shared_template_mappings():
-    """Returns shared template mappings."""
-    return [
-        {"template": "CHANGELOG.md.tpl", "target": "CHANGELOG.md"},
-        {"template": "gitignore.tpl", "target": ".gitignore"},
-        {"template": "LICENSE.tpl", "target": "LICENSE"},
-        {"template": "CLAUDE.md.tpl", "target": "CLAUDE.md"},
-        {"template": "hooks/pre-release.sh.tpl", "target": ".rlsbl/hooks/pre-release.sh"},
-        {"template": "hooks/post-release.sh.tpl", "target": ".rlsbl/hooks/post-release.sh"},
-        {"template": "claude-settings.json.tpl", "target": ".claude/settings.json"},
-    ]
-
-
-def check_project_exists(dir_path):
-    """Returns True if a pyproject.toml exists in the given directory."""
-    return os.path.exists(os.path.join(dir_path, "pyproject.toml"))
-
-
-def get_project_init_hint():
-    """Hint for users who haven't initialized their project yet."""
-    return 'Run "uv init" first'

package/rlsbl/tagging.py

@@ -1,207 +0,0 @@
-"""Tagging module: inject "rlsbl" keywords into manifests and GitHub topics."""
-
-import json
-import os
-import re
-import subprocess
-import tomllib
-import urllib.request
-import urllib.error
-
-from .utils import run
-
-
-def ensure_npm_keyword(dir_path=".", quiet=False):
-    """Add "rlsbl" to the keywords array in package.json if not already present."""
-    pkg_path = os.path.join(dir_path, "package.json")
-    with open(pkg_path, "r", encoding="utf-8") as f:
-        raw = f.read()
-
-    # Detect indent: look for the first indented line
-    indent_match = re.search(r'^( +|\t+)"', raw, re.MULTILINE)
-    indent = indent_match.group(1) if indent_match else "  "
-
-    pkg = json.loads(raw)
-    keywords = pkg.get("keywords", [])
-
-    if "rlsbl" in keywords:
-        return False
-
-    keywords.append("rlsbl")
-    pkg["keywords"] = keywords
-
-    # Preserve trailing newline if present
-    trailing_newline = "\n" if raw.endswith("\n") else ""
-    output = json.dumps(pkg, indent=indent, ensure_ascii=False) + trailing_newline
-
-    # Atomic write: write to temp file, then rename
-    tmp_path = pkg_path + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        f.write(output)
-    os.replace(tmp_path, pkg_path)
-
-    if not quiet:
-        print('Tagged package.json with "rlsbl" keyword')
-    return True
-
-
-def ensure_pypi_keyword(dir_path=".", quiet=False):
-    """Add "rlsbl" to the keywords array in pyproject.toml if not already present."""
-    toml_path = os.path.join(dir_path, "pyproject.toml")
-    with open(toml_path, "rb") as f:
-        data = tomllib.load(f)
-
-    # Check if already tagged
-    existing = data.get("project", {}).get("keywords", [])
-    if "rlsbl" in existing:
-        return False
-
-    # Read as text for regex-based editing
-    with open(toml_path, "r", encoding="utf-8") as f:
-        content = f.read()
-
-    # Find [project] section boundaries
-    project_match = re.search(r"^\[project\]\s*$", content, re.MULTILINE)
-    if not project_match:
-        raise ValueError("No [project] section found in pyproject.toml")
-
-    section_start = project_match.end()
-    next_section = re.search(r"^\[", content[section_start:], re.MULTILINE)
-    section_end = section_start + next_section.start() if next_section else len(content)
-    section = content[section_start:section_end]
-
-    # Case 1: keywords field already exists -- add "rlsbl" to the array
-    # Use DOTALL to handle multi-line arrays (e.g. keywords = [\n  "foo",\n])
-    keywords_match = re.search(r'^(keywords\s*=\s*\[)(.*?)\]', section, re.MULTILINE | re.DOTALL)
-    if keywords_match:
-        prefix = keywords_match.group(1)
-        array_content = keywords_match.group(2)
-        # Detect if multi-line (contains newline between brackets)
-        if "\n" in array_content:
-            # Multi-line: insert before the closing bracket on its own line
-            # Find the indent used for existing items
-            item_indent_match = re.search(r'\n( +)"', array_content)
-            item_indent = item_indent_match.group(1) if item_indent_match else "    "
-            # Strip trailing comma to avoid double comma when the list
-            # already has a trailing comma before the closing bracket
-            stripped = array_content.rstrip()
-            stripped = stripped.rstrip(",")
-            new_array_content = stripped + f',\n{item_indent}"rlsbl"\n'
-        else:
-            # Single-line
-            if array_content.strip():
-                stripped_sl = array_content.rstrip().rstrip(",")
-                new_array_content = stripped_sl + ', "rlsbl"'
-            else:
-                new_array_content = '"rlsbl"'
-        new_field = prefix + new_array_content + "]"
-        updated_section = section[:keywords_match.start()] + new_field + section[keywords_match.end():]
-    else:
-        # Case 2: keywords field missing -- insert after the version line
-        version_match = re.search(r'^version\s*=\s*"[^"]*"\s*$', section, re.MULTILINE)
-        if version_match:
-            insert_pos = version_match.end()
-        else:
-            # Fallback: insert at the beginning of the section
-            insert_pos = 0
-        updated_section = (
-            section[:insert_pos] + '\nkeywords = ["rlsbl"]' + section[insert_pos:]
-        )
-
-    updated = content[:section_start] + updated_section + content[section_end:]
-
-    # Atomic write: write to temp file, then rename
-    tmp_path = toml_path + ".tmp"
-    with open(tmp_path, "w", encoding="utf-8") as f:
-        f.write(updated)
-    os.replace(tmp_path, toml_path)
-
-    if not quiet:
-        print('Tagged pyproject.toml with "rlsbl" keyword')
-    return True
-
-
-def ensure_github_topic(quiet=False):
-    """Add "rlsbl" topic to the GitHub repository if not already present."""
-    # Try to get a GitHub token (env var first, then gh CLI)
-    token = os.environ.get("GITHUB_TOKEN")
-    if not token:
-        try:
-            token = run("gh", ["auth", "token"])
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            pass
-
-    if not token:
-        if not quiet:
-            print("No GitHub token available. Run 'gh auth login' or set GITHUB_TOKEN.")
-        return False
-
-    # Detect repo name
-    repo_name = None
-    try:
-        repo_name = run("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"])
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        pass
-
-    if not repo_name:
-        # Fallback: parse from git remote
-        try:
-            remote_url = run("git", ["remote", "get-url", "origin"])
-            match = re.search(r"github\.com[/:]([^/]+/[^/.]+)", remote_url)
-            if match:
-                repo_name = match.group(1).removesuffix(".git")
-        except (subprocess.CalledProcessError, FileNotFoundError):
-            pass
-
-    if not repo_name:
-        if not quiet:
-            print("Warning: could not detect GitHub repository name.")
-        return False
-
-    owner, repo = repo_name.split("/", 1)
-    api_url = f"https://api.github.com/repos/{owner}/{repo}/topics"
-    headers = {
-        "Authorization": f"token {token}",
-        "Accept": "application/vnd.github+json",
-        "User-Agent": "rlsbl-cli",
-    }
-
-    # GET existing topics
-    try:
-        req = urllib.request.Request(api_url, headers=headers)
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-    except (urllib.error.URLError, OSError, json.JSONDecodeError) as e:
-        if not quiet:
-            print(f"Warning: failed to fetch GitHub topics: {e}")
-        return False
-
-    topics = data.get("names", [])
-    if "rlsbl" in topics:
-        return False
-
-    # PUT with merged topics list
-    topics.append("rlsbl")
-    payload = json.dumps({"names": topics}).encode("utf-8")
-    try:
-        req = urllib.request.Request(api_url, data=payload, headers=headers, method="PUT")
-        req.add_header("Content-Type", "application/json")
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            resp.read()  # consume response
-    except (urllib.error.URLError, OSError) as e:
-        if not quiet:
-            print(f"Warning: failed to set GitHub topics: {e}")
-        return False
-
-    if not quiet:
-        print('Added "rlsbl" topic to GitHub repository')
-    return True
-
-
-def ensure_tags(registries, dir_path=".", quiet=False):
-    """Tag manifests and GitHub repo based on detected registries."""
-    if "npm" in registries:
-        ensure_npm_keyword(dir_path, quiet=quiet)
-    if "pypi" in registries:
-        ensure_pypi_keyword(dir_path, quiet=quiet)
-    ensure_github_topic(quiet=quiet)

package/rlsbl/templates/go/VERSION.tpl

@@ -1 +0,0 @@
-{{version}}

package/rlsbl/templates/go/ci.yml.tpl

@@ -1,21 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        go-version: ["1.22", "1.23", "1.24"]
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-go@v6
-        with:
-          go-version: ${{ matrix.go-version }}
-      - run: go test ./...
-      - run: go vet ./...

package/rlsbl/templates/go/goreleaser.yml.tpl

@@ -1,25 +0,0 @@
-version: 2
-
-builds:
-  - env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-      - windows
-    goarch:
-      - amd64
-      - arm64
-
-archives:
-  - format: tar.gz
-    name_template: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
-    format_overrides:
-      - goos: windows
-        format: zip
-
-checksum:
-  name_template: checksums.txt
-
-changelog:
-  use: github-native