rlsbl 0.0.1 → 0.1.0

package/rlsbl/commands/init_cmd.py

@@ -0,0 +1,321 @@
+"""Init command: scaffold release infrastructure from templates."""
+
+import hashlib
+import json
+import os
+import re
+import shutil
+import stat
+import sys
+
+from ..registries import REGISTRIES
+
+HASHES_FILE = os.path.join(".rlsbl", "hashes.json")
+
+# Files where existing content is preserved and template sections are appended
+APPENDABLE = {"CLAUDE.md"}
+APPEND_MARKER = "rlsbl"
+
+# Files where missing entries from the template are merged into the existing file
+MERGEABLE = {".gitignore"}
+
+# Files that are safe to overwrite during --update (managed files users typically don't customize)
+UPDATABLE = {
+    ".github/workflows/ci.yml",
+    ".github/workflows/publish.yml",
+    "scripts/check-prs.sh",
+    "scripts/pre-push-hook.sh",
+}
+
+def file_hash(path):
+    """SHA-256 hash of a file's contents."""
+    with open(path, "rb") as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+
+def load_hashes():
+    """Load stored file hashes from .rlsbl/hashes.json."""
+    if os.path.exists(HASHES_FILE):
+        with open(HASHES_FILE) as f:
+            return json.load(f)
+    return {}
+
+
+def save_hashes(hashes):
+    """Write file hashes to .rlsbl/hashes.json."""
+    os.makedirs(os.path.dirname(HASHES_FILE), exist_ok=True)
+    with open(HASHES_FILE, "w") as f:
+        json.dump(hashes, f, indent=2)
+        f.write("\n")
+
+
+NEXT_STEPS = {
+    "npm": [
+        "Add an NPM_TOKEN secret to your GitHub repo (Settings > Secrets > Actions)",
+        "Push to GitHub to activate the CI workflow",
+        "Run rlsbl npm release [patch|minor|major]",
+    ],
+    "pypi": [
+        "Push to GitHub",
+        "Configure Trusted Publishing on pypi.org",
+        "Run rlsbl pypi release [patch|minor|major]",
+    ],
+}
+
+
+def process_template(template_content, vars_dict):
+    """Process a template string by replacing {{varName}} placeholders with values.
+
+    Returns (content, unreplaced) where unreplaced is a list of unmatched var names.
+    """
+    unreplaced = []
+
+    def replacer(match):
+        var_name = match.group(1)
+        if var_name in vars_dict:
+            return vars_dict[var_name]
+        unreplaced.append(var_name)
+        return match.group(0)
+
+    content = re.sub(r"\{\{(\w+)\}\}", replacer, template_content)
+    return content, unreplaced
+
+
+def process_mappings(template_dir, mappings, vars_dict, force, update=False,
+                     existing_hashes=None):
+    """Process a list of template mappings: read each template, apply vars, write target files.
+
+    Skips existing files unless force is True, with special handling:
+    - APPENDABLE files: append template sections if the marker is not already present
+    - MERGEABLE files: merge missing entries from the template into the existing file
+    - UPDATABLE files (with --update): overwrite only if the file hasn't been customized
+      (detected via SHA-256 hash comparison against stored hashes)
+
+    Returns (created, skipped, warnings, new_hashes).
+    """
+    if existing_hashes is None:
+        existing_hashes = {}
+    created = []
+    skipped = []
+    warnings = []
+    new_hashes = {}
+
+    for mapping in mappings:
+        template = mapping["template"]
+        target = mapping["target"]
+
+        template_path = os.path.join(template_dir, template)
+        if not os.path.exists(template_path):
+            warnings.append(f"Template not found: {template_path}")
+            continue
+
+        # When file exists and force is not set, use context-aware handling
+        if os.path.exists(target) and not force:
+            basename = os.path.basename(target)
+
+            # In --update mode, overwrite managed files only if not customized
+            if update and target in UPDATABLE:
+                current_hash = file_hash(target)
+                stored_hash = existing_hashes.get(target)
+                if stored_hash and current_hash == stored_hash:
+                    # File matches stored hash -- not customized, safe to overwrite
+                    with open(template_path, "r", encoding="utf-8") as f:
+                        raw = f.read()
+                    content, unreplaced = process_template(raw, vars_dict)
+                    target_dir = os.path.dirname(target)
+                    if target_dir and target_dir != ".":
+                        os.makedirs(target_dir, exist_ok=True)
+                    with open(target, "w", encoding="utf-8") as f:
+                        f.write(content)
+                    new_hashes[target] = file_hash(target)
+                    created.append(target + " (updated)")
+                    if unreplaced:
+                        warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+                else:
+                    # File was customized or no stored hash -- skip conservatively
+                    # Seed the hash so future --update can detect changes
+                    new_hashes[target] = current_hash
+                    skipped.append(f"{target} (customized, use --force to overwrite)")
+                continue
+
+            if basename in APPENDABLE:
+                with open(target, "r", encoding="utf-8") as f:
+                    existing = f.read()
+                if APPEND_MARKER in existing:
+                    skipped.append(target + " (already has rlsbl section)")
+                    continue
+                # Append only the ## sections, stripping the top-level # heading
+                with open(template_path, "r", encoding="utf-8") as f:
+                    raw = f.read()
+                content, _ = process_template(raw, vars_dict)
+                lines = content.split("\n")
+                first_section_idx = None
+                for i, line in enumerate(lines):
+                    if i > 0 and line.startswith("## "):
+                        first_section_idx = i
+                        break
+                section = "\n".join(lines[first_section_idx:]) if first_section_idx is not None else content
+                with open(target, "a", encoding="utf-8") as f:
+                    f.write("\n\n" + section.strip() + "\n")
+                created.append(target + " (appended)")
+                continue
+
+            if basename in MERGEABLE:
+                with open(target, "r", encoding="utf-8") as f:
+                    existing = f.read()
+                with open(template_path, "r", encoding="utf-8") as f:
+                    raw = f.read()
+                content, _ = process_template(raw, vars_dict)
+                existing_lines = {
+                    line.strip() for line in existing.split("\n") if line.strip()
+                }
+                new_lines = [
+                    line.strip() for line in content.split("\n") if line.strip()
+                ]
+                # Only merge non-comment entries that are missing from the existing file
+                missing = [
+                    line for line in new_lines
+                    if line not in existing_lines and not line.startswith("#")
+                ]
+                if missing:
+                    with open(target, "a", encoding="utf-8") as f:
+                        f.write("\n# Added by rlsbl\n" + "\n".join(missing) + "\n")
+                    created.append(f"{target} (merged {len(missing)} entries)")
+                else:
+                    skipped.append(target + " (all entries present)")
+                continue
+
+            skipped.append(target)
+            continue
+
+        with open(template_path, "r", encoding="utf-8") as f:
+            raw = f.read()
+        content, unreplaced = process_template(raw, vars_dict)
+
+        # Ensure parent directory exists
+        target_dir = os.path.dirname(target)
+        if target_dir and target_dir != ".":
+            os.makedirs(target_dir, exist_ok=True)
+
+        with open(target, "w", encoding="utf-8") as f:
+            f.write(content)
+        new_hashes[target] = file_hash(target)
+        created.append(target)
+
+        if unreplaced:
+            warnings.append(f"{target}: unreplaced vars: {', '.join(unreplaced)}")
+
+    return created, skipped, warnings, new_hashes
+
+
+def run_cmd(registry, args, flags):
+    """Init command handler.
+
+    Scaffolds release infrastructure (CI, publish workflows, changelog, etc.)
+    from templates.
+    """
+    reg = REGISTRIES[registry]
+
+    # Check that a project file exists
+    if not reg.check_project_exists("."):
+        print(f"Error: no {registry} project found in current directory.", file=sys.stderr)
+        print(reg.get_project_init_hint(), file=sys.stderr)
+        sys.exit(1)
+
+    # Gather template variables
+    vars_dict = reg.get_template_vars(".")
+    from datetime import datetime
+    vars_dict["year"] = str(datetime.now().year)
+
+    force = flags.get("force", False)
+    update = flags.get("update", False)
+
+    existing_hashes = load_hashes()
+
+    # Process registry-specific templates
+    reg_created, reg_skipped, reg_warnings, reg_hashes = process_mappings(
+        reg.get_template_dir(),
+        reg.get_template_mappings(),
+        vars_dict,
+        force,
+        update,
+        existing_hashes,
+    )
+
+    # Process shared templates (skip if another registry already handled them)
+    shared_created, shared_skipped, shared_warnings, shared_hashes = [], [], [], {}
+    if not flags.get("skip-shared"):
+        shared_created, shared_skipped, shared_warnings, shared_hashes = process_mappings(
+            reg.get_shared_template_dir(),
+            reg.get_shared_template_mappings(),
+            vars_dict,
+            force,
+            update,
+            existing_hashes,
+        )
+
+    # Make all shell scripts in scripts/ executable
+    scripts_dir = os.path.join(".", "scripts")
+    if os.path.isdir(scripts_dir):
+        for entry in os.listdir(scripts_dir):
+            if entry.endswith(".sh"):
+                os.chmod(os.path.join(scripts_dir, entry), 0o755)
+
+    # Auto-install pre-push hook if not already present
+    hook_source = os.path.join("scripts", "pre-push-hook.sh")
+    hook_target = os.path.join(".git", "hooks", "pre-push")
+    if os.path.exists(hook_source) and os.path.isdir(".git"):
+        if not os.path.exists(hook_target):
+            os.makedirs(os.path.join(".git", "hooks"), exist_ok=True)
+            shutil.copy2(hook_source, hook_target)
+            os.chmod(hook_target, 0o755)
+            print("Installed pre-push hook (.git/hooks/pre-push)")
+
+    # Write scaffolding version marker so the pre-push hook can detect drift
+    from rlsbl import __version__
+    marker_dir = os.path.join(".", ".rlsbl")
+    os.makedirs(marker_dir, exist_ok=True)
+    marker_path = os.path.join(marker_dir, "version")
+    with open(marker_path, "w") as f:
+        f.write(__version__ + "\n")
+    print("Wrote scaffolding version marker (.rlsbl/version)")
+
+    # Persist file hashes for future --update customization detection
+    all_new_hashes = {}
+    all_new_hashes.update(reg_hashes)
+    all_new_hashes.update(shared_hashes)
+    existing_hashes.update(all_new_hashes)
+    save_hashes(existing_hashes)
+
+    # Merge results
+    created = reg_created + shared_created
+    skipped = reg_skipped + shared_skipped
+    warnings = reg_warnings + shared_warnings
+
+    # Print summary
+    if created:
+        print("Created:")
+        for f in created:
+            print(f"  {f}")
+
+    if skipped:
+        print("Skipped (already exist, use --update to refresh managed files or --force to overwrite all):")
+        for f in skipped:
+            print(f"  {f}")
+
+    if warnings:
+        print("Warnings:")
+        for w in warnings:
+            print(f"  {w}")
+
+    # Helpful note when existing CI workflow is preserved
+    ci_path = ".github/workflows/ci.yml"
+    if any(s.startswith(ci_path) for s in skipped):
+        print("\nNote: Existing CI workflow preserved. Review and merge manually if needed.")
+
+    # Next steps
+    steps = NEXT_STEPS.get(registry)
+    if steps:
+        print("\nNext steps:")
+        for i, step in enumerate(steps, 1):
+            print(f"  {i}. {step}")

package/rlsbl/commands/release.py

@@ -0,0 +1,179 @@
+"""Release command: bump version, commit, push, create GitHub Release."""
+
+import os
+import sys
+import time
+
+from ..registries import REGISTRIES
+from ..utils import (
+    bump_version,
+    check_gh_auth,
+    check_gh_installed,
+    extract_changelog_entry,
+    find_commit_tool,
+    get_current_branch,
+    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}")
+
+    # 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)
+
+    # Compute new version
+    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(".", "scripts", "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}")
+        log(f"Bump:      {current_version} -> {new_version} ({bump_type})")
+        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_files.append(other_reg.get_version_file())
+        if other_files:
+            log(f"Sync to:   {', '.join(other_files)}")
+        log(f"Changelog:\n{changelog_entry}")
+        log("--- No changes made ---")
+        return
+
+    # Write new version to the primary registry file
+    version_file = reg.get_version_file()
+    reg.write_version(".", new_version)
+    log(f"Updated version in {version_file}")
+
+    # Sync version to all other recognized version files
+    files_to_commit = [version_file]
+    for name, other_reg in REGISTRIES.items():
+        if name == registry:
+            continue
+        if other_reg.check_project_exists("."):
+            other_reg.write_version(".", new_version)
+            other_file = other_reg.get_version_file()
+            files_to_commit.append(other_file)
+            log(f"Synced version to {other_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])
+    else:
+        run("git", ["add", *files_to_commit])
+        run("git", ["commit", "-m", tag])
+    log(f"Committed: {tag}")
+
+    # Create local git tag
+    run("git", ["tag", tag])
+    log(f"Tagged: {tag}")
+
+    # Push commits and tag
+    push_if_needed(branch)
+    run("git", ["push", "origin", tag])
+    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)
+
+    log(f"\nRelease {new_version} complete!")

package/rlsbl/commands/status.py

@@ -0,0 +1,76 @@
+"""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()
+            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/registries/__init__.py

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