rlsbl 0.4.0 → 0.4.2

package/README.md

@@ -1,6 +1,10 @@
+<p align="center">
+  <img src="logo.svg" alt="rlsbl" width="336" height="105">
+</p>
+
 # 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 +29,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 +39,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 +60,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 +127,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 +146,15 @@ 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. Go projects use GoReleaser in CI (via GitHub Actions) to build cross-platform binaries.
+
+## Environment variables
 
-After configuration, all subsequent releases are handled by CI when `rlsbl release` creates a GitHub Release.
+| 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. |
 
 ## Requirements
 

package/package.json

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

package/rlsbl/commands/init_cmd.py

@@ -61,7 +61,7 @@ NEXT_STEPS = {
         "Run rlsbl release [patch|minor|major]",
     ],
     "go": [
-        "Install GoReleaser (https://goreleaser.com/install/)",
+        "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

@@ -12,6 +12,7 @@ from ..utils import (
     extract_changelog_entry,
     find_commit_tool,
     get_current_branch,
+    get_push_timeout,
     is_clean_tree,
     push_if_needed,
     run,
@@ -55,19 +56,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
 
-    # Compute new version
-    new_version = bump_version(current_version, bump_type)
-    tag = f"v{new_version}"
-    log(f"New version: {new_version} ({bump_type})")
+    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])
@@ -111,7 +123,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
@@ -144,7 +159,8 @@ def run_cmd(registry, args, flags):
 
     # 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}")
         if files_to_commit:
             print(f"  Files: {', '.join(files_to_commit)}")
@@ -159,23 +175,24 @@ def run_cmd(registry, args, flags):
             print("Aborted.")
             sys.exit(0)
 
-    # Write new version to the primary registry file
-    if version_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_file = other_reg.get_version_file()
-            if other_file:
-                other_reg.write_version(".", new_version)
-                log(f"Synced version to {other_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}")
 
-    # Commit all bumped version files together
-    if files_to_commit:
+    # 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])
@@ -184,15 +201,18 @@ def run_cmd(registry, args, flags):
             run("git", ["commit", "-m", tag])
         log(f"Committed: {tag}")
     else:
-        log("No version files to commit (version is the git tag)")
+        log("No version bump 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])
+    run("git", ["push", "origin", tag], timeout=push_timeout)
     log(f"Pushed to origin/{branch}")
 
     # Create GitHub Release using a temp notes file

package/rlsbl/commands/undo.py

@@ -2,7 +2,7 @@
 
 import sys
 
-from ..utils import run, run_silent, check_gh_installed, check_gh_auth
+from ..utils import run, check_gh_installed, check_gh_auth, get_push_timeout
 
 
 def run_cmd(registry, args, flags):
@@ -40,7 +40,7 @@ def run_cmd(registry, args, flags):
 
     # Delete remote tag
     try:
-        run("git", ["push", "origin", f":{tag}"])
+        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}")

package/rlsbl/registries/go.py

@@ -1,8 +1,7 @@
 """Go registry adapter for rlsbl.
 
-Go modules are versioned by git tags, not version files. GoReleaser handles
-the build/publish step. rlsbl's role: changelog validation, tagging, GitHub
-Release creation.
+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
@@ -12,28 +11,30 @@ from ..utils import run
 
 NAME = "go"
 
+VERSION_FILE = "VERSION"
 
-def read_version(dir_path):
-    """Read version from the latest git tag.
 
-    Go modules have no version file -- the version IS the git tag.
-    Returns "0.0.0" if no tags exist yet.
-    """
-    try:
-        tag = run("git", ["describe", "--tags", "--abbrev=0"])
-        return tag.lstrip("v")
-    except Exception:
-        return "0.0.0"
+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):
-    """No-op: Go versions are git tags, not file fields."""
-    pass
+    """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():
-    """Go has no version file -- version is the git tag."""
-    return None
+    """Returns the filename that holds the version for this registry."""
+    return VERSION_FILE
 
 
 def get_template_dir():
@@ -73,7 +74,10 @@ def get_template_vars(dir_path):
     except Exception:
         pass
 
-    version = read_version(dir_path)
+    try:
+        version = read_version(dir_path)
+    except FileNotFoundError:
+        version = "0.0.0"
 
     return {
         "name": short_name,
@@ -88,6 +92,7 @@ def get_template_vars(dir_path):
 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"},

package/rlsbl/utils.py

@@ -7,21 +7,13 @@ import subprocess
 import sys
 
 
-def run(cmd, args=None, timeout=30):
+def run(cmd, args=None, timeout=120):
     """Run a command with args, return trimmed stdout. Raise on failure."""
     full_cmd = [cmd] + (args or [])
     result = subprocess.run(full_cmd, capture_output=True, text=True, check=True, timeout=timeout)
     return result.stdout.strip()
 
 
-def run_silent(cmd, args=None, timeout=30):
-    """Run a command suppressing stderr. Return trimmed stdout. Raise on failure."""
-    full_cmd = [cmd] + (args or [])
-    result = subprocess.run(
-        full_cmd, capture_output=True, text=True, check=True, timeout=timeout,
-    )
-    return result.stdout.strip()
-
 
 def is_clean_tree():
     """Returns True if the git working tree is clean (no uncommitted changes)."""
@@ -34,18 +26,34 @@ def get_current_branch():
     return run("git", ["rev-parse", "--abbrev-ref", "HEAD"])
 
 
+def get_push_timeout():
+    """Return the push timeout in seconds, from RLSBL_PUSH_TIMEOUT or default 120."""
+    raw = os.environ.get("RLSBL_PUSH_TIMEOUT")
+    if raw is None:
+        return 120
+    try:
+        val = int(raw)
+        if val <= 0:
+            raise ValueError
+        return val
+    except ValueError:
+        print(f'Warning: invalid RLSBL_PUSH_TIMEOUT="{raw}", using default 120s', file=sys.stderr)
+        return 120
+
+
 def push_if_needed(branch):
     """Push the branch to origin if local is ahead of remote."""
+    timeout = get_push_timeout()
     local = run("git", ["rev-parse", branch])
     try:
         remote = run("git", ["rev-parse", f"origin/{branch}"])
     except subprocess.CalledProcessError:
         # Remote branch doesn't exist yet; push it
-        run("git", ["push", "-u", "origin", branch])
+        run("git", ["push", "-u", "origin", branch], timeout=timeout)
         return
 
     if local != remote:
-        run("git", ["push", "origin", branch])
+        run("git", ["push", "origin", branch], timeout=timeout)
 
 
 def extract_changelog_entry(changelog_path, version):
@@ -93,11 +101,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/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."