rlsbl 0.3.0 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # rlsbl
 
-Release orchestration and project scaffolding CLI for npm and PyPI.
+Release orchestration and project scaffolding CLI for npm, PyPI, and Go.
 
 ## Install
 
@@ -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 `--registry <npm|pypi>` when you need to target a specific registry.
+All commands work at the top level -- registries are auto-detected from project files (`package.json`, `pyproject.toml`, `go.mod`). Use `--registry <npm|pypi|go>` when you need to target a specific registry.
 
 ### scaffold [--force] [--update]
 
@@ -35,6 +35,7 @@ Scaffolds CI/CD infrastructure and release tooling for all detected registries.
 rlsbl scaffold
 rlsbl scaffold --registry npm          # target npm only
 rlsbl scaffold --registry pypi --force # overwrite existing files
+rlsbl scaffold --registry go           # target Go only
 ```
 
 Context-aware behavior when files already exist (without `--force`):
@@ -55,7 +56,7 @@ rlsbl release minor
 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.
+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.
 
@@ -122,7 +123,7 @@ The scaffolded `scripts/pre-push-hook.sh` is installed as a git pre-push hook du
 
 How it works:
 
-1. Detects project type (`package.json` or `pyproject.toml`)
+1. Detects project type (`package.json`, `pyproject.toml`, or `VERSION`)
 2. Extracts the current version
 3. Checks that `CHANGELOG.md` contains a heading `## <version>`
 4. Blocks the push with an error if the entry is missing
@@ -141,8 +142,9 @@ The first version must be published manually before CI can take over:
 |---|---|---|
 | npm | Add an `NPM_TOKEN` secret to your GitHub repo (Settings > Secrets > Actions), then push a release | CI handles subsequent publishes |
 | PyPI | Run `uv publish` | Set up [Trusted Publishing](https://docs.pypi.org/trusted-publishers/) on pypi.org |
+| Go | Push to GitHub and create a release -- Go modules are published by the tag itself | No secrets needed; `pkg.go.dev` indexes automatically |
 
-After configuration, all subsequent releases are handled by CI when `rlsbl release` creates a GitHub Release.
+After configuration, all subsequent releases are handled by CI when `rlsbl release` creates a GitHub Release. Go projects use GoReleaser in CI (via GitHub Actions) to build cross-platform binaries.
 
 ## Requirements
 

package/package.json

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

package/rlsbl/__init__.py

@@ -1,4 +1,4 @@
-"""rlsbl: Release orchestration and project scaffolding for npm and PyPI."""
+"""rlsbl: Release orchestration and project scaffolding for npm, PyPI, and Go."""
 
 import os
 import sys
@@ -9,12 +9,12 @@ try:
 except Exception:
     __version__ = "unknown"
 
-REGISTRIES = ("npm", "pypi")
+REGISTRIES = ("npm", "pypi", "go")
 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
+rlsbl v{__version__} -- Release orchestration and project scaffolding for npm, PyPI, and Go
 
 Usage:
   rlsbl release [patch|minor|major] [--dry-run] [--yes] [--quiet]  Orchestrate a release
@@ -25,7 +25,7 @@ Usage:
   rlsbl undo [--yes]                                        Revert the last release
 
 Options:
-  --registry <npm|pypi>  Target a specific registry (auto-detected if omitted)
+  --registry <npm|pypi|go>  Target a specific registry (auto-detected if omitted)
   --help, -h             Show this help
   --version, -v          Show version"""
 
@@ -40,6 +40,8 @@ def detect_registries():
         found.append("npm")
     if os.path.exists("pyproject.toml"):
         found.append("pypi")
+    if os.path.exists("go.mod"):
+        found.append("go")
     return found
 
 
@@ -144,9 +146,10 @@ def main():
             if registry:
                 handler.run_cmd(registry, args, flags)
             else:
-                for i, r in enumerate(["npm", "pypi"]):
+                all_registries = ["npm", "pypi", "go"]
+                for i, r in enumerate(all_registries):
                     handler.run_cmd(r, args, flags)
-                    if i < 1:
+                    if i < len(all_registries) - 1:
                         print("")
         elif command == "scaffold":
             if registry:
@@ -154,7 +157,7 @@ def main():
             else:
                 regs = detect_registries()
                 if not regs:
-                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    print("Error: no package.json, pyproject.toml, or go.mod found.", file=sys.stderr)
                     sys.exit(1)
                 if len(regs) > 1:
                     handler.run_cmd_multi(regs, args, flags)
@@ -169,7 +172,7 @@ def main():
             if not registry:
                 regs = detect_registries()
                 if not regs:
-                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    print("Error: no package.json, pyproject.toml, or go.mod found.", file=sys.stderr)
                     sys.exit(1)
                 registry = regs[0]
             handler.run_cmd(registry, args, flags)
@@ -178,7 +181,7 @@ def main():
             if not registry:
                 regs = detect_registries()
                 if not regs:
-                    print("Error: no package.json or pyproject.toml found.", file=sys.stderr)
+                    print("Error: no package.json, pyproject.toml, or go.mod found.", file=sys.stderr)
                     sys.exit(1)
                 registry = regs[0]
             handler.run_cmd(registry, args, flags)

package/rlsbl/commands/check.py

@@ -1,4 +1,4 @@
-"""Check command: check package name availability on npm or PyPI."""
+"""Check command: check package name availability on npm, PyPI, or Go (pkg.go.dev)."""
 
 import re
 import subprocess
@@ -165,10 +165,44 @@ def _check_name_pypi(name):
             )
 
 
+def check_go_availability(name):
+    """Check if a Go module path exists on pkg.go.dev.
+
+    Returns {"status": "available"|"taken"|"error", "message"?: str}.
+    """
+    url = f"https://pkg.go.dev/{name}"
+    try:
+        req = urllib.request.Request(url, method="GET")
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            if resp.status == 200:
+                return {"status": "taken"}
+            return {"status": "error", "message": f"Unexpected status {resp.status}"}
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return {"status": "available"}
+        return {"status": "error", "message": f"Unexpected status {e.code}"}
+    except Exception as e:
+        return {"status": "error", "message": str(e) or "Network error"}
+
+
+def _check_name_go(name):
+    """Check Go module path availability on pkg.go.dev."""
+    print(f'Checking pkg.go.dev for "{name}"...')
+
+    result = check_go_availability(name)
+    if result["status"] == "error":
+        print(f"Error checking pkg.go.dev: {result['message']}", file=sys.stderr)
+        sys.exit(1)
+    if result["status"] == "available":
+        print(f'"{name}" is available on pkg.go.dev.')
+    else:
+        print(f'"{name}" already exists on pkg.go.dev.')
+
+
 def run_cmd(registry, args, flags):
     """Check command handler.
 
-    Checks package name availability on npm or PyPI, and warns about similar names.
+    Checks package name availability on npm, PyPI, or Go, and warns about similar names.
     """
     name = args[0] if args else None
     if not name:
@@ -180,5 +214,7 @@ def run_cmd(registry, args, flags):
 
     if registry == "npm":
         _check_name_npm(name)
-    else:
+    elif registry == "pypi":
         _check_name_pypi(name)
+    elif registry == "go":
+        _check_name_go(name)

package/rlsbl/commands/config.py

@@ -9,7 +9,8 @@ def run_cmd(registry, args, flags):
     for name, reg in REGISTRIES.items():
         if reg.check_project_exists("."):
             version = reg.read_version(".")
-            print(f"  {name}: {reg.get_version_file()} (v{version})")
+            vfile = reg.get_version_file() or "git tag"
+            print(f"  {name}: {vfile} (v{version})")
         else:
             print(f"  {name}: not found")
 

package/rlsbl/commands/init_cmd.py

@@ -60,6 +60,11 @@ NEXT_STEPS = {
         "Configure Trusted Publishing on pypi.org",
         "Run rlsbl release [patch|minor|major]",
     ],
+    "go": [
+        "GoReleaser runs in CI via GitHub Actions (no local install needed)",
+        "Push to GitHub to activate the CI workflow",
+        "Run rlsbl release [patch|minor|major]",
+    ],
 }
 
 

package/rlsbl/commands/release.py

@@ -55,19 +55,30 @@ def run_cmd(registry, args, flags):
     current_version = reg.read_version(".")
     log(f"Current version: {current_version}")
 
-    # Bump type
-    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)
+    # 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)
 
-    # Compute new version
-    new_version = bump_version(current_version, bump_type)
-    tag = f"v{new_version}"
-    log(f"New version: {new_version} ({bump_type})")
+        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])
@@ -111,7 +122,10 @@ def run_cmd(registry, args, flags):
     if flags.get("dry-run", False):
         log("\n--- Dry run summary ---")
         log(f"Registry:  {registry}")
-        log(f"Bump:      {current_version} -> {new_version} ({bump_type})")
+        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
@@ -120,7 +134,9 @@ def run_cmd(registry, args, flags):
             if name == registry:
                 continue
             if other_reg.check_project_exists("."):
-                other_files.append(other_reg.get_version_file())
+                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}")
@@ -129,18 +145,26 @@ def run_cmd(registry, args, flags):
 
     # Pre-compute which files will be modified
     version_file = reg.get_version_file()
-    files_to_commit = [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("."):
-            files_to_commit.append(other_reg.get_version_file())
+            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"):
-        print(f"\nAbout to release {new_version} ({bump_type}) on {branch}")
+        bump_label = f" ({bump_type})" if bump_type else ""
+        print(f"\nAbout to release {new_version}{bump_label} on {branch}")
         print(f"  Tag: {tag}")
-        print(f"  Files: {', '.join(files_to_commit)}")
+        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):
@@ -150,26 +174,33 @@ def run_cmd(registry, args, flags):
             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}")
+    # 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_reg.write_version(".", new_version)
-            log(f"Synced version to {other_reg.get_version_file()}")
-
-    # Commit all bumped version files together
-    commit_tool = find_commit_tool()
-    if commit_tool == "safegit":
-        run(commit_tool, ["commit", "-m", tag, "--", *files_to_commit])
+        # 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}")
+
+    # Commit version file changes (skip if version didn't change, e.g. first release)
+    if files_to_commit and new_version != current_version:
+        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}")
     else:
-        run("git", ["add", *files_to_commit])
-        run("git", ["commit", "-m", tag])
-    log(f"Committed: {tag}")
+        log("No version bump to commit")
 
     # Create local git tag
     run("git", ["tag", tag])

package/rlsbl/commands/status.py

@@ -33,7 +33,7 @@ def run_cmd(registry, args, flags):
     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()
+            file = r_mod.get_version_file() or "git tag"
             print(f"Version:   {ver} ({r_name}, {file})")
 
     # Git info

package/rlsbl/registries/__init__.py

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

package/rlsbl/registries/go.py

@@ -0,0 +1,124 @@
+"""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,
+    }
+
+
+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": "check-prs.sh.tpl", "target": "scripts/check-prs.sh"},
+        {"template": "claude-settings.json.tpl", "target": ".claude/settings.json"},
+        {"template": "record-gif.sh.tpl", "target": "scripts/record-gif.sh"},
+        {"template": "pre-release.sh.tpl", "target": "scripts/pre-release.sh"},
+        {"template": "pre-push-hook.sh.tpl", "target": "scripts/pre-push-hook.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/utils.py

@@ -93,11 +93,10 @@ def check_gh_auth():
 def find_commit_tool():
     """Detect safegit or fall back to git for committing.
 
-    Returns the path/name of the commit tool.
+    Returns "safegit" if available on PATH, otherwise "git".
     """
-    safegit_path = shutil.which("safegit")
-    if safegit_path:
-        return safegit_path
+    if shutil.which("safegit"):
+        return "safegit"
     return "git"
 
 

package/templates/go/VERSION.tpl

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

package/templates/go/ci.yml.tpl

@@ -0,0 +1,21 @@
+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@v5
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+      - run: go test ./...
+      - run: go vet ./...

package/templates/go/goreleaser.yml.tpl

@@ -0,0 +1,25 @@
+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

package/templates/go/publish.yml.tpl

@@ -0,0 +1,25 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+      - uses: goreleaser/goreleaser-action@v6
+        with:
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/templates/shared/pre-push-hook.sh.tpl

@@ -9,6 +9,8 @@ if [ -f package.json ]; then
   VERSION=$(node -e "console.log(require('./package.json').version)" 2>/dev/null) || exit 0
 elif [ -f pyproject.toml ]; then
   VERSION=$(grep -m1 '^version' pyproject.toml | sed 's/.*"\(.*\)".*/\1/') || exit 0
+elif [ -f VERSION ]; then
+  VERSION=$(tr -d '[:space:]' < VERSION) || exit 0
 else
   exit 0
 fi

package/templates/shared/pre-release.sh.tpl

@@ -1,13 +1,27 @@
 #!/usr/bin/env bash
 # Pre-release validation hook.
 # Runs before rlsbl creates a release. Exit non-zero to abort.
-# Add your project-specific checks here (e.g., tests, linting, audit).
+# Detects project type and runs appropriate checks automatically.
 
 set -euo pipefail
 
 echo "Running pre-release checks..."
 
-# Example: run tests if available
-# npm test 2>/dev/null || true
+if [ -f go.mod ]; then
+  echo "Detected Go project"
+  go vet ./...
+  go build ./...
+  go test ./... -race -short -count=1
+elif [ -f package.json ]; then
+  echo "Detected npm project"
+  npm test
+elif [ -f pyproject.toml ]; then
+  echo "Detected Python project"
+  if command -v uv &>/dev/null; then
+    uv run pytest
+  elif command -v pytest &>/dev/null; then
+    pytest
+  fi
+fi
 
 echo "Pre-release checks passed."