rlsbl 0.0.1 → 0.1.0

package/rlsbl/registries/npm.py

@@ -0,0 +1,120 @@
+"""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) + 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,
+    }
+
+
+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": "check-prs.sh.tpl", "target": "scripts/check-prs.sh"},
+        {"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"},
+        {"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

@@ -0,0 +1,172 @@
+"""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,
+    }
+
+
+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": "check-prs.sh.tpl", "target": "scripts/check-prs.sh"},
+        {"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"},
+        {"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/utils.py

@@ -0,0 +1,124 @@
+"""Git helpers, version bump, changelog extraction, and other shared utilities."""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+
+def run(cmd, args=None, timeout=30):
+    """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)."""
+    status = run("git", ["status", "--porcelain"])
+    return len(status) == 0
+
+
+def get_current_branch():
+    """Returns the current git branch name."""
+    return run("git", ["rev-parse", "--abbrev-ref", "HEAD"])
+
+
+def push_if_needed(branch):
+    """Push the branch to origin if local is ahead of remote."""
+    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])
+        return
+
+    if local != remote:
+        run("git", ["push", "origin", branch])
+
+
+def extract_changelog_entry(changelog_path, version):
+    """Extract a changelog entry for a specific version.
+
+    Looks for a heading like '## 1.2.3' and captures everything
+    until the next heading or EOF.
+    """
+    with open(changelog_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    escaped_version = re.escape(version)
+    header_pattern = re.compile(r"^## " + escaped_version + r"\s*$", re.MULTILINE)
+    match = header_pattern.search(content)
+    if not match:
+        return None
+
+    # Start after the matched header line
+    start_idx = match.end()
+    # Find the next "## " heading or use end of string
+    next_heading_idx = content.find("\n## ", start_idx)
+    end_idx = len(content) if next_heading_idx == -1 else next_heading_idx
+    entry = content[start_idx:end_idx].strip()
+    return entry or None
+
+
+def check_gh_installed():
+    """Check that the gh CLI is installed."""
+    try:
+        run("gh", ["--version"])
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def check_gh_auth():
+    """Check that the gh CLI is authenticated."""
+    try:
+        run("gh", ["auth", "status"])
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def find_commit_tool():
+    """Detect safegit or fall back to git for committing.
+
+    Returns the path/name of the commit tool.
+    """
+    safegit_path = shutil.which("safegit")
+    if safegit_path:
+        return safegit_path
+    return "git"
+
+
+def bump_version(version, bump_type):
+    """Bump a semver version string by the given type (patch, minor, major).
+
+    Returns the new version string.
+    """
+    parts = version.split(".")
+    if len(parts) != 3:
+        raise ValueError(f'Invalid semver version: "{version}"')
+    try:
+        major, minor, patch = (int(p) for p in parts)
+    except ValueError:
+        raise ValueError(f'Invalid semver version: "{version}"')
+
+    if bump_type == "major":
+        return f"{major + 1}.0.0"
+    elif bump_type == "minor":
+        return f"{major}.{minor + 1}.0"
+    elif bump_type == "patch":
+        return f"{major}.{minor}.{patch + 1}"
+    else:
+        raise ValueError(f'Invalid bump type: "{bump_type}". Use patch, minor, or major.')

package/templates/npm/ci.yml.tpl

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: ${{ matrix.node-version }}
+      - run: node -e "require('./package.json')"
+      - run: npm test --if-present
+      - run: npm audit --audit-level=moderate || true

package/templates/npm/publish.yml.tpl

@@ -0,0 +1,22 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/templates/pypi/ci.yml.tpl

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: astral-sh/setup-uv@v8
+      - run: uv python install ${{ matrix.python-version }}
+      - run: uv sync
+      - run: uv run python -c "import {{importName}}"

package/templates/pypi/publish.yml.tpl

@@ -0,0 +1,18 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: astral-sh/setup-uv@v8
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

package/templates/shared/CHANGELOG.md.tpl

@@ -0,0 +1,5 @@
+# Changelog
+
+## {{version}}
+
+- Initial release

package/templates/shared/CLAUDE.md.tpl

@@ -0,0 +1,20 @@
+# {{name}}
+
+## Release workflow
+
+This project uses [rlsbl](https://github.com/smm-h/rlsbl) for release orchestration.
+
+- Update CHANGELOG.md with a `## X.Y.Z` entry describing changes
+- Run `rlsbl <registry> release [patch|minor|major]` to bump version and create a GitHub Release
+- CI handles publishing automatically via the publish workflow
+- Never publish manually — always use `rlsbl <registry> release`
+- Requires `NPM_TOKEN` secret on GitHub (for npm projects)
+- Use `rlsbl <registry> release --dry-run` to preview a release without making changes
+
+## Conventions
+
+- No tokens or secrets in command-line arguments (use env vars or config files)
+- All file writes to shared state should be atomic (write to tmp, then rename)
+- External calls (APIs, CLI tools) must have timeouts and graceful fallbacks
+- Use `npm link` (npm) or `uv pip install -e .` (Python) for local development
+- CI runs smoke tests on every push; manual testing for UI/UX changes

package/templates/shared/LICENSE.tpl

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) {{year}} {{author}}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/templates/shared/check-prs.sh.tpl

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# List open PRs for awareness at session start.
+# Safe to run in hooks -- always exits 0.
+cd "$(git rev-parse --show-toplevel 2>/dev/null)" || exit 0
+count=$(gh pr list --state open --json number --jq length 2>/dev/null) || exit 0
+if [ "$count" -gt 0 ]; then
+  echo "Open PRs: $count"
+  gh pr list --state open
+fi
+exit 0

package/templates/shared/claude-settings.json.tpl

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./scripts/check-prs.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/shared/gitignore.tpl

@@ -0,0 +1,13 @@
+node_modules/
+__pycache__/
+*.pyc
+*.log
+.DS_Store
+coverage/
+dist/
+*.egg-info/
+.rlsbl-notes-*.tmp
+.credentials.json
+.*-cache.json
+.env
+.env.local

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

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Pre-push hook: verify CHANGELOG.md has an entry for the current version.
+# Install: cp scripts/pre-push-hook.sh .git/hooks/pre-push && chmod +x .git/hooks/pre-push
+
+set -euo pipefail
+
+# Detect project type and extract version
+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
+else
+  exit 0
+fi
+
+if [ -z "$VERSION" ]; then
+  exit 0
+fi
+
+# Check CHANGELOG.md has an entry for this version
+if [ ! -f CHANGELOG.md ]; then
+  echo "Warning: CHANGELOG.md not found."
+  exit 0
+fi
+
+if ! grep -q "^## $VERSION" CHANGELOG.md; then
+  echo "Error: CHANGELOG.md has no entry for version $VERSION."
+  echo "Add a '## $VERSION' section before pushing."
+  exit 1
+fi
+
+# Check scaffolding freshness
+if [ -f .rlsbl/version ]; then
+  SCAFFOLD_VER=$(cat .rlsbl/version | tr -d '[:space:]')
+  if command -v rlsbl &>/dev/null; then
+    CURRENT_VER=$(rlsbl --version 2>/dev/null | tr -d '[:space:]')
+    if [ -n "$CURRENT_VER" ] && [ "$SCAFFOLD_VER" != "$CURRENT_VER" ]; then
+      echo "Warning: scaffolding was generated by rlsbl $SCAFFOLD_VER but you have $CURRENT_VER installed."
+      echo "Run 'rlsbl scaffold --update' to update scaffolding."
+    fi
+  fi
+fi

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

@@ -0,0 +1,13 @@
+#!/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).
+
+set -euo pipefail
+
+echo "Running pre-release checks..."
+
+# Example: run tests if available
+# npm test 2>/dev/null || true
+
+echo "Pre-release checks passed."