rlsbl 0.8.2 → 0.9.0

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "rlsbl",
-  "version": "0.8.2",
-  "description": "Release orchestration and project scaffolding for npm and PyPI",
+  "version": "0.9.0",
+  "description": "Release orchestration and project scaffolding for npm, PyPI, and Go",
   "license": "MIT",
   "bin": {
     "rlsbl": "bin/cli.js"
   },
   "files": [
-    "bin/",
-    "rlsbl/",
-    "templates/"
+    "bin/"
   ],
   "repository": {
     "type": "git",

package/rlsbl/__init__.py

@@ -1,247 +0,0 @@
-"""rlsbl: Release orchestration and project scaffolding for npm, PyPI, and Go."""
-
-import os
-import sys
-
-
-def _detect_version():
-    """Detect package version, preferring pyproject.toml over installed metadata.
-
-    Order: pyproject.toml in the source tree (accurate during editable installs)
-    -> importlib.metadata (works for regular installs) -> "unknown".
-    """
-    # Try reading version from pyproject.toml next to the package source
-    try:
-        pyproject_path = os.path.realpath(
-            os.path.join(os.path.dirname(__file__), "..", "pyproject.toml")
-        )
-        if os.path.isfile(pyproject_path):
-            try:
-                import tomllib
-            except ModuleNotFoundError:
-                import tomli as tomllib  # type: ignore[no-redef]
-            with open(pyproject_path, "rb") as f:
-                data = tomllib.load(f)
-            return data["project"]["version"]
-    except Exception:
-        pass
-
-    # Fall back to installed dist-info metadata
-    try:
-        from importlib.metadata import version as _get_version
-        return _get_version("rlsbl")
-    except Exception:
-        pass
-
-    return "unknown"
-
-
-__version__ = _detect_version()
-
-REGISTRIES = ("npm", "pypi", "go")
-COMMANDS = ("release", "status", "scaffold", "check", "config", "undo", "discover", "watch",
-            "pre-push-check", "record-gif")
-COMMAND_ALIASES = {"init": "scaffold"}
-
-HELP = f"""\
-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
-  rlsbl status                                              Show project status
-  rlsbl scaffold [--force] [--update]                       Scaffold release infrastructure
-  rlsbl check <name>                                        Check name availability
-  rlsbl config                                              Show project configuration
-  rlsbl undo [--yes]                                        Revert the last release
-  rlsbl discover [--mine]                                   List rlsbl ecosystem projects
-  rlsbl watch [<commit-sha>]                                Watch CI runs for a commit
-  rlsbl pre-push-check                                     Verify CHANGELOG entry for current version
-  rlsbl record-gif [--width N] [--height N] [--font-size N] [--duration N]
-                                                            Record a demo GIF with vhs
-
-Options:
-  --registry <npm|pypi|go>  Target a specific registry (auto-detected if omitted)
-  --no-tag               Disable ecosystem tagging for this invocation
-  --help, -h             Show this help
-  --version, -v          Show version"""
-
-
-def detect_registries():
-    """Detect all registries that have a project file in the current directory.
-
-    Returns a list, e.g. ["npm"], ["pypi"], or ["npm", "pypi"].
-    """
-    found = []
-    if os.path.exists("package.json"):
-        found.append("npm")
-    if os.path.exists("pyproject.toml"):
-        found.append("pypi")
-    if os.path.exists("go.mod"):
-        found.append("go")
-    return found
-
-
-def parse_args(argv):
-    """Parse sys.argv into positional args and flags.
-
-    Flags listed in VALUE_FLAGS consume the next token as their value
-    (e.g. --registry npm). All other --flags are boolean.
-    """
-    VALUE_FLAGS = ("registry", "width", "height", "font-size", "duration")
-    raw = argv[1:]
-    positional = []
-    flags = {}
-    i = 0
-    while i < len(raw):
-        arg = raw[i]
-        if arg.startswith("--"):
-            key = arg[2:]
-            if "=" in key:
-                k, v = key.split("=", 1)
-                flags[k] = v
-            elif key in VALUE_FLAGS and i + 1 < len(raw) and not raw[i + 1].startswith("-"):
-                flags[key] = raw[i + 1]
-                i += 1
-            else:
-                flags[key] = True
-        elif arg.startswith("-") and len(arg) == 2:
-            flags[arg[1:]] = True
-        else:
-            positional.append(arg)
-        i += 1
-    return positional, flags
-
-
-def _get_command_module(command):
-    """Import and return the command module for the given command name."""
-    # Map CLI command names to Python module names
-    module_map = {
-        "release": "release",
-        "status": "status",
-        "scaffold": "init_cmd",
-        "check": "check",
-        "config": "config",
-        "undo": "undo",
-        "discover": "discover",
-        "watch": "watch",
-        "pre-push-check": "pre_push_check",
-        "record-gif": "record_gif",
-    }
-    module_name = module_map.get(command)
-    if not module_name:
-        return None
-
-    # Import the command module
-    from importlib import import_module
-    return import_module(f".commands.{module_name}", package="rlsbl")
-
-
-def main():
-    positional, flags = parse_args(sys.argv)
-
-    # Top-level flags
-    if flags.get("help") or flags.get("h"):
-        print(HELP)
-        sys.exit(0)
-
-    if flags.get("version") or flags.get("v"):
-        print(__version__)
-        sys.exit(0)
-
-    command = positional[0] if positional else None
-
-    # Resolve command aliases (e.g. "init" -> "scaffold")
-    if command in COMMAND_ALIASES:
-        command = COMMAND_ALIASES[command]
-
-    if not command:
-        print("Error: missing command.\n", file=sys.stderr)
-        print(HELP, file=sys.stderr)
-        sys.exit(1)
-
-    if command not in COMMANDS:
-        print(f'Error: unknown command "{command}".\n', file=sys.stderr)
-        print(HELP, file=sys.stderr)
-        sys.exit(1)
-
-    args = positional[1:]
-    registry = flags.get("registry")
-
-    # --registry was the last arg with no value following it
-    if registry is True:
-        print("Error: --registry requires a value (npm, pypi, or go).", file=sys.stderr)
-        sys.exit(1)
-
-    # Validate --registry if provided
-    if registry and registry not in REGISTRIES:
-        print(
-            f"Error: unknown registry '{registry}'. Valid: {', '.join(REGISTRIES)}",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    try:
-        handler = _get_command_module(command)
-        if handler is None:
-            print(f'Error: command "{command}" is not yet implemented.', file=sys.stderr)
-            sys.exit(1)
-
-        if command == "check":
-            # check: if registry given, check that one; otherwise check npm and pypi.
-            # Go is excluded from the default set because Go modules use repository
-            # paths (e.g. github.com/user/repo), not a flat claimable namespace, so
-            # "available" would be misleading.  Pass --registry go explicitly to check.
-            if registry:
-                handler.run_cmd(registry, args, flags)
-            else:
-                default_registries = ["npm", "pypi"]
-                for i, r in enumerate(default_registries):
-                    handler.run_cmd(r, args, flags)
-                    if i < len(default_registries) - 1:
-                        print("")
-        elif command == "scaffold":
-            if registry:
-                handler.run_cmd(registry, args, flags)
-            else:
-                regs = detect_registries()
-                if not regs:
-                    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)
-                else:
-                    handler.run_cmd(regs[0], args, flags)
-        elif command == "config":
-            # config: auto-detect, pass first registry or fallback
-            regs = detect_registries()
-            handler.run_cmd(registry or (regs[0] if regs else "npm"), args, flags)
-        elif command == "undo":
-            # undo: auto-detect like release
-            if not registry:
-                regs = detect_registries()
-                if not regs:
-                    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)
-        elif command == "discover":
-            # discover: global query, no registry needed
-            handler.run_cmd(registry, args, flags)
-        elif command == "watch":
-            # watch: monitors CI runs, no registry needed
-            handler.run_cmd(registry, args, flags)
-        elif command in ("pre-push-check", "record-gif"):
-            # Standalone commands, no registry needed
-            handler.run_cmd(registry, args, flags)
-        else:
-            # release, status: use explicit registry or auto-detect primary
-            if not registry:
-                regs = detect_registries()
-                if not regs:
-                    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)
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)

package/rlsbl/__main__.py

@@ -1,4 +0,0 @@
-"""Allow running as python -m rlsbl."""
-from . import main
-
-main()

package/rlsbl/commands/check.py

@@ -1,229 +0,0 @@
-"""Check command: check package name availability on npm, PyPI, or Go (pkg.go.dev)."""
-
-import re
-import subprocess
-import sys
-import urllib.request
-import urllib.error
-
-
-def normalize_npm(name):
-    """Normalize an npm package name for similarity comparison.
-
-    Strips hyphens, underscores, dots, and lowercases.
-    """
-    return re.sub(r"[-_.]", "", name.lower())
-
-
-def normalize_pypi(name):
-    """Normalize a PyPI package name per PEP 503.
-
-    Lowercases and replaces runs of [-_.] with a single hyphen.
-    """
-    return re.sub(r"[-_.]+", "-", name.lower())
-
-
-def check_npm_availability(name):
-    """Check if an npm package name is available.
-
-    Returns {"status": "available"|"taken"|"error", "message"?: str}.
-    Distinguishes 404 (truly available) from network/other errors.
-    """
-    try:
-        subprocess.run(
-            ["npm", "view", name, "name"],
-            capture_output=True, text=True, check=True,
-        )
-        return {"status": "taken"}
-    except subprocess.CalledProcessError as e:
-        stderr = e.stderr or ""
-        if "E404" in stderr or "404" in stderr:
-            return {"status": "available"}
-        return {"status": "error", "message": stderr.strip() or "Unknown error checking npm"}
-    except FileNotFoundError:
-        return {"status": "error", "message": "npm CLI not found"}
-
-
-def get_npm_variants(name):
-    """Generate common npm name variants for similarity checking."""
-    variants = set()
-    lower = name.lower()
-    variants.add(lower)
-    variants.add(lower.replace("_", "-"))
-    variants.add(lower.replace("-", "_"))
-    variants.add(re.sub(r"[-_]", "", lower))
-    variants.add(re.sub(r"[-_]", ".", lower))
-
-    # Remove the original name itself from the set
-    variants.discard(name)
-
-    return list(variants)
-
-
-def check_pypi_availability(name):
-    """Check if a PyPI package name is available.
-
-    Returns {"status": "available"|"taken"|"error", "message"?: str}.
-    Distinguishes 404 (truly available) from network/other errors.
-    """
-    url = f"https://pypi.org/pypi/{name}/json"
-    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 get_pypi_variants(name):
-    """Generate common PyPI name variants for similarity checking."""
-    normalized = normalize_pypi(name)
-    lower = name.lower()
-    variants = set()
-    variants.add(normalized)
-    variants.add(re.sub(r"[-_.]+", "_", lower))
-    variants.add(re.sub(r"[-_.]+", "-", lower))
-    variants.add(re.sub(r"[-_.]+", "", lower))
-
-    # Remove the original name itself
-    variants.discard(name)
-
-    return list(variants)
-
-
-def _check_name_npm(name):
-    """Check npm availability and report similar names."""
-    print(f'Checking npm for "{name}"...')
-
-    result = check_npm_availability(name)
-    if result["status"] == "error":
-        print(f"Error checking npm: {result['message']}", file=sys.stderr)
-        sys.exit(1)
-    available = result["status"] == "available"
-    if available:
-        print(f'"{name}" is available on npm.')
-    else:
-        print(f'"{name}" is taken on npm.')
-
-    # Check variants for similarity; skip variants that error
-    variants = get_npm_variants(name)
-    similar = []
-    for variant in variants:
-        var_result = check_npm_availability(variant)
-        if var_result["status"] == "taken":
-            similar.append(variant)
-
-    if similar:
-        print("\nSimilar names already taken:")
-        for s in similar:
-            print(f"  {s}")
-        if available:
-            print(
-                "\nYour name is available but has similar existing packages. "
-                "Consider if this could cause confusion."
-            )
-
-
-def _check_name_pypi(name):
-    """Check PyPI availability and report similar names."""
-    print(f'Checking PyPI for "{name}"...')
-
-    result = check_pypi_availability(name)
-    if result["status"] == "error":
-        print(f"Error checking PyPI: {result['message']}", file=sys.stderr)
-        sys.exit(1)
-    available = result["status"] == "available"
-    if available:
-        print(f'"{name}" is available on PyPI.')
-    else:
-        print(f'"{name}" is taken on PyPI.')
-
-    # Check variants for similarity (PEP 503 normalization); skip variants that error
-    variants = get_pypi_variants(name)
-    similar = []
-    for variant in variants:
-        if variant == name:
-            continue
-        var_result = check_pypi_availability(variant)
-        if var_result["status"] == "taken":
-            similar.append(variant)
-
-    if similar:
-        print("\nSimilar names already taken:")
-        for s in similar:
-            print(f"  {s}")
-        if available:
-            print(
-                "\nYour name is available but has similar existing packages. "
-                "Consider if this could cause confusion."
-            )
-
-
-def check_go_availability(name):
-    """Check if a Go module path exists on pkg.go.dev.
-
-    Returns {"status": "not_found"|"exists"|"error", "message"?: str, "note"?: str}.
-
-    Go modules use repository paths (e.g. github.com/user/repo), not a flat
-    claimable namespace, so we report "not found" / "exists" rather than the
-    "available" / "taken" language used for npm and PyPI.
-    """
-    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": "exists"}
-            return {"status": "error", "message": f"Unexpected status {resp.status}"}
-    except urllib.error.HTTPError as e:
-        if e.code == 404:
-            return {
-                "status": "not_found",
-                "note": "Go modules use repository paths, not a central registry.",
-            }
-        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 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"] == "not_found":
-        print(f'"{name}" not found on pkg.go.dev.')
-    else:
-        print(f'"{name}" exists on pkg.go.dev.')
-    if result.get("note"):
-        print(f"  Note: {result['note']}")
-
-
-def run_cmd(registry, args, flags):
-    """Check command handler.
-
-    Checks package name availability on npm, PyPI, or Go, and warns about similar names.
-    """
-    name = args[0] if args else None
-    if not name:
-        print(
-            "Error: missing package name. Usage: rlsbl check <name>",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    if registry == "npm":
-        _check_name_npm(name)
-    elif registry == "pypi":
-        _check_name_pypi(name)
-    elif registry == "go":
-        _check_name_go(name)

package/rlsbl/commands/config.py

@@ -1,67 +0,0 @@
-"""Config command: show resolved project configuration."""
-
-import os
-from ..config import _project_config, USER_CONFIG, read_json_config, should_tag
-from ..registries import REGISTRIES
-
-
-def run_cmd(registry, args, flags):
-    print("Detected registries:")
-    for name, reg in REGISTRIES.items():
-        if reg.check_project_exists("."):
-            version = reg.read_version(".")
-            vfile = reg.get_version_file() or "git tag"
-            print(f"  {name}: {vfile} (v{version})")
-        else:
-            print(f"  {name}: not found")
-
-    print("\nScaffolding:")
-    rlsbl_dir = os.path.join(".", ".rlsbl")
-    if os.path.isdir(rlsbl_dir):
-        version_file = os.path.join(rlsbl_dir, "version")
-        if os.path.exists(version_file):
-            with open(version_file) as f:
-                scaffold_ver = f.read().strip()
-            print(f"  Version marker: {scaffold_ver}")
-        hashes_file = os.path.join(rlsbl_dir, "hashes.json")
-        if os.path.exists(hashes_file):
-            import json
-            with open(hashes_file) as f:
-                hashes = json.load(f)
-            print(f"  Tracked files: {len(hashes)}")
-            for path in sorted(hashes):
-                print(f"    {path}")
-    else:
-        print("  Not scaffolded (run 'rlsbl scaffold')")
-
-    print("\nWorkflows:")
-    for wf in ["ci.yml", "publish.yml", "workflow.yml"]:
-        path = os.path.join(".github", "workflows", wf)
-        print(f"  {wf}: {'yes' if os.path.exists(path) else 'no'}")
-
-    print("\nHooks:")
-    pre_release = os.path.join(".rlsbl", "hooks", "pre-release.sh")
-    print(f"  pre-release.sh: {'yes' if os.path.exists(pre_release) else 'no'}")
-    post_release = os.path.join(".rlsbl", "hooks", "post-release.sh")
-    print(f"  post-release.sh: {'yes' if os.path.exists(post_release) else 'no'}")
-    pre_push = os.path.join(".git", "hooks", "pre-push")
-    print(f"  pre-push hook: {'installed' if os.path.exists(pre_push) else 'not installed'}")
-
-    print("\nEcosystem tagging:")
-    enabled = should_tag(flags)
-    # Determine why it's enabled/disabled
-    project_cfg = read_json_config(_project_config())
-    user_cfg = read_json_config(USER_CONFIG)
-    if flags.get("no-tag"):
-        source = "CLI flag"
-    elif "tag" in project_cfg:
-        source = f"project config ({_project_config()})"
-    elif "tag" in user_cfg:
-        source = f"user config ({USER_CONFIG})"
-    else:
-        source = "default"
-    print(f"  Status: {'enabled' if enabled else 'disabled'} ({source})")
-
-    print("\nFiles:")
-    for f in ["CHANGELOG.md", "LICENSE", ".gitignore", "CLAUDE.md"]:
-        print(f"  {f}: {'yes' if os.path.exists(f) else 'no'}")