rlsbl 0.8.3 → 0.9.1

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'}")

package/rlsbl/commands/discover.py

@@ -1,198 +0,0 @@
-"""Discover command: list projects in the rlsbl ecosystem."""
-
-import json
-import os
-import subprocess
-import sys
-import urllib.error
-import urllib.request
-
-
-SEARCH_URL = "https://api.github.com/search/repositories?q=topic:rlsbl&sort=updated&per_page=100"
-MAX_RESULTS = 1000
-
-
-def _get_github_token():
-    """Get a GitHub token from GITHUB_TOKEN env or `gh auth token`."""
-    token = os.environ.get("GITHUB_TOKEN")
-    if token:
-        return token
-    try:
-        result = subprocess.run(
-            ["gh", "auth", "token"],
-            capture_output=True, text=True, check=True, timeout=10,
-        )
-        return result.stdout.strip() or None
-    except Exception:
-        return None
-
-
-def _make_request(url, token):
-    """Make a GET request to the GitHub API, return parsed JSON and response headers."""
-    req = urllib.request.Request(url, method="GET")
-    req.add_header("Accept", "application/vnd.github+json")
-    req.add_header("User-Agent", "rlsbl-cli")
-    if token:
-        req.add_header("Authorization", f"token {token}")
-    with urllib.request.urlopen(req, timeout=15) as resp:
-        data = json.loads(resp.read().decode("utf-8"))
-        headers = dict(resp.headers)
-        return data, headers
-
-
-def _parse_next_link(headers):
-    """Extract the 'next' URL from the Link header, or None."""
-    link = headers.get("Link") or headers.get("link")
-    if not link:
-        return None
-    for part in link.split(","):
-        if 'rel="next"' in part:
-            start = part.index("<") + 1
-            end = part.index(">")
-            url = part[start:end]
-            if not url.startswith("https://api.github.com/"):
-                return None
-            return url
-    return None
-
-
-def _relative_time(iso_timestamp):
-    """Convert an ISO 8601 timestamp to a relative time string like '2d ago'."""
-    from datetime import datetime, timezone
-
-    if not iso_timestamp:
-        return ""
-
-    # Parse ISO timestamp (GitHub uses Z suffix)
-    ts = iso_timestamp.replace("Z", "+00:00")
-    dt = datetime.fromisoformat(ts)
-    now = datetime.now(timezone.utc)
-    delta = now - dt
-
-    seconds = int(delta.total_seconds())
-    if seconds < 60:
-        return "just now"
-    minutes = seconds // 60
-    if minutes < 60:
-        return f"{minutes}m ago"
-    hours = minutes // 60
-    if hours < 24:
-        return f"{hours}h ago"
-    days = hours // 24
-    if days < 7:
-        return f"{days}d ago"
-    weeks = days // 7
-    if weeks < 5:
-        return f"{weeks}w ago"
-    months = days // 30
-    if months < 12:
-        return f"{months}mo ago"
-    years = days // 365
-    return f"{years}y ago"
-
-
-def _get_authenticated_user(token):
-    """Get the authenticated user's login name."""
-    if not token:
-        return None
-    try:
-        req = urllib.request.Request("https://api.github.com/user", method="GET")
-        req.add_header("Accept", "application/vnd.github+json")
-        req.add_header("User-Agent", "rlsbl-cli")
-        req.add_header("Authorization", f"token {token}")
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-            return data.get("login")
-    except Exception:
-        return None
-
-
-def _fetch_all_repos(token):
-    """Fetch all repos with the rlsbl topic, handling pagination."""
-    repos = []
-    url = SEARCH_URL
-
-    while url and len(repos) < MAX_RESULTS:
-        data, headers = _make_request(url, token)
-        items = data.get("items", [])
-        repos.extend(items)
-        url = _parse_next_link(headers)
-
-    return repos
-
-
-def run_cmd(registry, args, flags):
-    """Discover command: list projects in the rlsbl ecosystem."""
-    token = _get_github_token()
-    mine_only = flags.get("mine", False)
-
-    if mine_only and not token:
-        print("Error: --mine requires authentication (set GITHUB_TOKEN or install gh CLI).", file=sys.stderr)
-        sys.exit(1)
-
-    # Fetch repos
-    try:
-        repos = _fetch_all_repos(token)
-    except urllib.error.HTTPError as e:
-        print(f"Error: GitHub API returned {e.code}: {e.reason}", file=sys.stderr)
-        if e.code == 403:
-            print("Hint: run 'gh auth login' to increase API rate limits (60/hr unauthenticated → 5000/hr).", file=sys.stderr)
-        sys.exit(1)
-    except urllib.error.URLError as e:
-        print(f"Error: could not reach GitHub API: {e.reason}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    # Filter to --mine if requested
-    if mine_only:
-        username = _get_authenticated_user(token)
-        if not username:
-            print("Error: could not determine authenticated user.", file=sys.stderr)
-            sys.exit(1)
-        repos = [r for r in repos if r.get("owner", {}).get("login") == username]
-
-    if not repos:
-        if mine_only:
-            print("No rlsbl-tagged repositories found for your account.")
-        else:
-            print("No rlsbl-tagged repositories found.")
-        return
-
-    # Build table rows
-    rows = []
-    for repo in repos:
-        full_name = repo.get("full_name", "")
-        description = repo.get("description") or ""
-        updated = _relative_time(repo.get("updated_at", ""))
-        rows.append((full_name, description, updated))
-
-    # Calculate column widths
-    name_width = max(len(r[0]) for r in rows)
-    desc_width = max(len(r[1]) for r in rows)
-    time_width = max(len(r[2]) for r in rows)
-
-    # Cap description width to keep output readable
-    max_desc = 40
-    if desc_width > max_desc:
-        desc_width = max_desc
-
-    # Ensure minimum widths match headers
-    name_width = max(name_width, len("owner/repo"))
-    desc_width = max(desc_width, len("description"))
-    time_width = max(time_width, len("updated"))
-
-    # Print header
-    print(f"\nrlsbl ecosystem ({len(repos)} projects)\n")
-    header = f"  {'owner/repo':<{name_width}}  {'description':<{desc_width}}  {'updated':<{time_width}}"
-    print(header)
-    separator_len = name_width + desc_width + time_width + 6
-    print(f"  {'─' * separator_len}")
-
-    # Print rows
-    for full_name, description, updated in rows:
-        # Truncate long descriptions
-        if len(description) > max_desc:
-            description = description[:max_desc - 1] + "…"
-        print(f"  {full_name:<{name_width}}  {description:<{desc_width}}  {updated}")