git-repokit 0.9.10__py3-none-any.whl

repokit/auth_integration.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Authentication handler for RepoKit.
+
+Manages authentication with remote services like GitHub and GitLab.
+"""
+
+import os
+import json
+import logging
+import subprocess
+from pathlib import Path
+from typing import Dict, Any, Optional, Tuple
+
+
+class AuthenticationHandler:
+    """
+    Handles authentication with remote services.
+    """
+
+    def __init__(self, verbose: int = 0):
+        """
+        Initialize the authentication handler.
+
+        Args:
+            verbose: Verbosity level (0=normal, 1=info, 2=debug)
+        """
+        self.verbose = verbose
+        self.logger = logging.getLogger("repokit.auth")
+
+        # Default locations for credentials
+        self.user_home = Path.home()
+        self.default_creds_path = self.user_home / ".repokit" / "credentials.json"
+
+        # Initialize with empty credentials
+        self.credentials = {}
+
+    def load_credentials(self, credentials_file: Optional[str] = None) -> bool:
+        """
+        Load credentials from a file.
+
+        Args:
+            credentials_file: Path to credentials file (or None to use default)
+
+        Returns:
+            True if loaded successfully, False otherwise
+        """
+        if credentials_file:
+            creds_path = Path(credentials_file)
+        elif self.default_creds_path.exists():
+            creds_path = self.default_creds_path
+        else:
+            if self.verbose >= 1:
+                self.logger.info("No credentials file found")
+            return False
+
+        try:
+            with open(creds_path, "r") as f:
+                self.credentials = json.load(f)
+
+            if self.verbose >= 1:
+                self.logger.info(f"Loaded credentials from {creds_path}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Error loading credentials: {str(e)}")
+            return False
+
+    def get_token(
+        self, service: str, token_command: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Get authentication token for a service.
+
+        Tries multiple sources in this order:
+        1. Command provided token command
+        2. Environment variable
+        3. Credentials file
+
+        Args:
+            service: Service name ('github' or 'gitlab')
+            token_command: Optional command to retrieve token from password manager
+
+        Returns:
+            Authentication token or None if not found
+        """
+        # Standardize service name
+        service = service.lower()
+
+        # 1. Try token command if provided
+        if token_command:
+            try:
+                if self.verbose >= 2:
+                    self.logger.debug(f"Running token command: {token_command}")
+                result = subprocess.run(
+                    token_command,
+                    shell=True,
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                token = result.stdout.strip()
+                if token:
+                    if self.verbose >= 1:
+                        self.logger.info(f"Retrieved {service} token using command")
+                    return token
+            except Exception as e:
+                self.logger.error(f"Failed to get token from command: {str(e)}")
+
+        # 2. Try environment variable
+        env_var = f"{service.upper()}_TOKEN"
+        token = os.environ.get(env_var)
+        if token:
+            if self.verbose >= 1:
+                self.logger.info(f"Using {service} token from environment variable")
+            return token
+
+        # 3. Try credentials file
+        if service in self.credentials and "token" in self.credentials[service]:
+            if self.verbose >= 1:
+                self.logger.info(f"Using {service} token from credentials file")
+            return self.credentials[service]["token"]
+
+        # Token not found
+        self.logger.warning(f"No {service} token found")
+        return None
+
+    def get_organization(self, service: str) -> Optional[str]:
+        """
+        Get organization or group for a service.
+
+        Args:
+            service: Service name ('github' or 'gitlab')
+
+        Returns:
+            Organization/group name or None if not specified
+        """
+        # Standardize service name
+        service = service.lower()
+
+        # Try environment variable first
+        env_var = f"{service.upper()}_ORGANIZATION"
+        if service == "gitlab":
+            env_var = "GITLAB_GROUP"  # GitLab uses "group" terminology
+
+        org = os.environ.get(env_var)
+        if org:
+            return org
+
+        # Try credentials file
+        if service in self.credentials:
+            if service == "github" and "organization" in self.credentials[service]:
+                return self.credentials[service]["organization"]
+            elif service == "gitlab" and "group" in self.credentials[service]:
+                return self.credentials[service]["group"]
+
+        return None
+
+    def get_api_url(self, service: str) -> str:
+        """
+        Get API URL for a service.
+
+        Args:
+            service: Service name ('github' or 'gitlab')
+
+        Returns:
+            API URL for the service
+        """
+        if service.lower() == "github":
+            return os.environ.get("GITHUB_API_URL", "https://api.github.com")
+        elif service.lower() == "gitlab":
+            return os.environ.get("GITLAB_API_URL", "https://gitlab.com/api/v4")
+        else:
+            return ""
+
+    def store_credentials(
+        self,
+        service: str,
+        token: str,
+        organization: Optional[str] = None,
+        file_path: Optional[str] = None,
+    ) -> bool:
+        """
+        Store credentials in the credentials file.
+
+        Args:
+            service: Service name ('github' or 'gitlab')
+            token: Authentication token
+            organization: Organization or group name (optional)
+            file_path: Path to credentials file (or None to use default)
+
+        Returns:
+            True if stored successfully, False otherwise
+        """
+        # Standardize service name
+        service = service.lower()
+
+        # Load existing credentials if file exists
+        if file_path:
+            creds_path = Path(file_path)
+        else:
+            creds_path = self.default_creds_path
+            # Ensure directory exists
+            creds_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Load existing credentials if file exists
+        existing_creds = {}
+        if creds_path.exists():
+            try:
+                with open(creds_path, "r") as f:
+                    existing_creds = json.load(f)
+            except Exception as e:
+                self.logger.error(f"Error loading existing credentials: {str(e)}")
+                # Continue with empty credentials
+
+        # Update credentials
+        service_creds = existing_creds.get(service, {})
+        service_creds["token"] = token
+
+        if organization:
+            if service == "github":
+                service_creds["organization"] = organization
+            elif service == "gitlab":
+                service_creds["group"] = organization
+
+        existing_creds[service] = service_creds
+
+        # Save credentials
+        try:
+            with open(creds_path, "w") as f:
+                json.dump(existing_creds, f, indent=2)
+
+            # Set restrictive permissions
+            os.chmod(creds_path, 0o600)
+
+            if self.verbose >= 1:
+                self.logger.info(f"Stored {service} credentials in {creds_path}")
+
+            # Update in-memory credentials
+            self.credentials = existing_creds
+
+            return True
+        except Exception as e:
+            self.logger.error(f"Error storing credentials: {str(e)}")
+            return False

repokit/badges.py

@@ -0,0 +1,183 @@
+"""README badges in the house's shape (0.9.7).
+
+Measured on 2026-10-25 across the 107 house projects under C:\\code
+(tests/one-offs/thinking/p4-measure-badges/) and settled with djdarcy; the
+design is notes/2026-10-25__00-02-16__both_readme-badge-sets__the-house-badges-and-how-repokit-picks-them.md
+in the vault.
+
+- TYPES is the catalogue: each badge's commonest house form, filled per
+  project, inline (`[![alt](image)](link)`) as the house writes them.
+- TEMPLATES are ordered lists. The general ones follow djdarcy's slots:
+  where to get it (PyPI, else the release), when it was released, package
+  downloads, runtime, other package locations, licence, discussions,
+  ghstats, platform last (the commitment that the tools work everywhere).
+  ComfyUI keeps its own order: the Registry is where a node comes from.
+- CI is a filler: in when it lands on a row that already exists, out when
+  it would start a row by itself (ROW badges per row).
+- The licence's colour is its house colour (GPL/AGPL green, MIT yellow,
+  others orange), switched to the next of green, yellow, orange when it would
+  equal a neighbour's colour.
+
+A person's own templates (`badge_templates`) and badge types
+(`badge_types`, each naming `after` to take its place in the order) come
+from the global config; `--badges NAME|a,b,c` or the config's `badges`
+picks one.
+"""
+from typing import Dict, List, Optional, Sequence
+
+ROW = 7  # shields badges per row of a GitHub README (to be checked on a render)
+
+# id -> (alt, image, link, colour). {owner} {repo} {dist} {python} {node}
+# {license_label} {license_url} {gist_user} {gist} {pages} are filled per
+# project; {colour} is the badge's resolved colour.
+TYPES: Dict[str, tuple] = {
+    "pypi-version": ("PyPI", "https://img.shields.io/pypi/v/{dist}?color={colour}",
+                     "https://pypi.org/project/{dist}/", "green"),
+    "release-date": ("Release Date", "https://img.shields.io/github/release-date/{owner}/{repo}?color={colour}",
+                     "https://github.com/{owner}/{repo}/releases", "green"),
+    "downloads": ("PyPI Downloads",
+                  "https://static.pepy.tech/personalized-badge/{dist}?period=total&units=international_system"
+                  "&left_color=black&right_color={colour}&left_text=downloads",
+                  "https://pypistats.org/packages/{dist}", "green"),
+    "release-version": ("GitHub release",
+                        "https://img.shields.io/github/v/release/{owner}/{repo}?include_prereleases&label=version",
+                        "https://github.com/{owner}/{repo}/releases", "blue"),
+    "ci": ("CI", "https://github.com/{owner}/{repo}/actions/workflows/{ci}/badge.svg",
+           "https://github.com/{owner}/{repo}/actions/workflows/{ci}", "default"),
+    "python": ("Python {python}+", "https://img.shields.io/badge/python-{python}+-{colour}.svg",
+               "https://www.python.org/downloads/", "blue"),
+    "node": ("Node {node}+", "https://img.shields.io/badge/node-{node}+-{colour}.svg",
+             "https://nodejs.org/en/download", "blue"),
+    "comfyui-registry": ("ComfyUI Registry", "https://img.shields.io/badge/ComfyUI-Registry-{colour}.svg",
+                         "https://registry.comfy.org/publishers/{gist_user}/nodes/{repo_lower}", "green"),
+    "license": ("License: {license_label}", "https://img.shields.io/badge/license-{license_badge}-{colour}.svg",
+                "{license_url}", "contrast"),
+    "discussions": ("GitHub Discussions", "https://img.shields.io/github/discussions/{owner}/{repo}",
+                    "https://github.com/{owner}/{repo}/discussions", "blue"),
+    "installs": ("Installs",
+                 "https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/{gist_user}/{gist}/raw/installs.json",
+                 "https://{pages}.github.io/{repo}/stats/#installs", "blue"),
+    "views": ("Views",
+              "https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/{gist_user}/{gist}/raw/views.json",
+              "https://{pages}.github.io/{repo}/stats/#views", "blue"),
+    "platform": ("Platform", "https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-{colour}.svg",
+                 "{platform_link}", "lightgrey"),
+}
+
+# The default order: djdarcy's slots, CI after the release slots. A badge type
+# a person adds names its place with `after`.
+ORDER = ["pypi-version", "release-date", "downloads", "release-version", "ci", "python", "node",
+         "comfyui-registry", "license", "discussions", "installs", "views", "platform"]
+
+TEMPLATES: Dict[str, List[str]] = {
+    "pypi": ["pypi-version", "release-date", "downloads", "ci", "runtime", "license", "discussions",
+             "installs", "platform"],
+    "github": ["release-version", "ci", "runtime", "license", "discussions", "installs", "platform"],
+    # its own order: the Registry is where a node comes from (djdarcy, 2026-10-25)
+    "comfyui": ["runtime", "comfyui-registry", "release-version", "license", "installs", "views"],
+    "minimal": ["runtime", "license"],
+}
+
+# The default template for a preset
+PRESET_TEMPLATE = {"python/pypi": "pypi", "python/comfyui": "comfyui"}
+
+# licence id -> (badge text, the licence's page, house colour)
+LICENSES = {
+    "gpl-3.0": ("GPL v3", "https://www.gnu.org/licenses/gpl-3.0.html", "green"),
+    "gpl-3.0-or-later": ("GPL v3", "https://www.gnu.org/licenses/gpl-3.0.html", "green"),
+    "agpl-3.0": ("AGPL v3", "https://www.gnu.org/licenses/agpl-3.0.html", "green"),
+    "agpl-3.0-or-later": ("AGPL v3", "https://www.gnu.org/licenses/agpl-3.0.html", "green"),
+    "lgpl-3.0": ("LGPL v3", "https://www.gnu.org/licenses/lgpl-3.0.html", "green"),
+    "lgpl-3.0-or-later": ("LGPL v3", "https://www.gnu.org/licenses/lgpl-3.0.html", "green"),
+    "gpl-2.0": ("GPL v2", "https://www.gnu.org/licenses/old-licenses/gpl-2.0.html", "green"),
+    "mit": ("MIT", "https://opensource.org/licenses/MIT", "yellow"),
+    "apache-2.0": ("Apache 2.0", "https://opensource.org/licenses/Apache-2.0", "orange"),
+}
+CONTRAST = ["green", "yellow", "orange"]
+
+
+class BadgeError(ValueError):
+    """A template or badge name the catalogue does not know."""
+
+
+def _shields_text(text: str) -> str:
+    """A static shields badge's text: '-' doubled, '_' doubled, spaces escaped."""
+    return text.replace("-", "--").replace("_", "__").replace(" ", "%20")
+
+
+def resolve(request, archetype: Optional[str], templates: Optional[dict] = None,
+            types: Optional[dict] = None) -> List[str]:
+    """The badge ids for a request: a template name, a list of ids, or None
+    (the preset's default template)."""
+    templates = {**TEMPLATES, **(templates or {})}
+    known = set(TYPES) | set(types or {}) | {"runtime"}
+    if request is None or request == "":
+        request = PRESET_TEMPLATE.get(archetype or "", "github")
+    if isinstance(request, str) and "," not in request:
+        if request not in templates:
+            if request in known:
+                return [request]
+            raise BadgeError(f"unknown badge template {request!r}; known: {', '.join(sorted(templates))}")
+        names = list(templates[request])
+    else:
+        names = [n.strip() for n in (request.split(",") if isinstance(request, str) else request) if n.strip()]
+        order = ORDER + [t for t in (types or {})]
+        names = sorted(dict.fromkeys(names), key=lambda n: order.index(n) if n in order else len(order))
+    unknown = [n for n in names if n not in known]
+    if unknown:
+        raise BadgeError(f"unknown badges {', '.join(unknown)}; known: {', '.join(sorted(known))}")
+    return names
+
+
+def render(names: Sequence[str], values: Dict[str, str], ci: str = "auto",
+           types: Optional[dict] = None) -> str:
+    """The badge lines, one per line, inline. `values` fills the tokens; a
+    badge whose required value is missing (no CI file, no runtime floor) is
+    left out. `ci` is auto, on or off."""
+    catalogue = dict(TYPES)
+    for tid, spec in (types or {}).items():  # a person's own badge lines
+        catalogue[tid] = (spec.get("alt", tid), spec["image"], spec.get("link", ""), spec.get("colour", "default"))
+    picked = []
+    for n in names:
+        if n == "runtime":
+            n = "python" if values.get("python") else "node" if values.get("node") else None
+            if not n:
+                continue
+        if n == "ci" and not values.get("ci"):
+            continue
+        if n == "license" and not values.get("license_badge"):
+            continue
+        if n in ("python",) and not values.get("python"):
+            continue
+        if n in ("node",) and not values.get("node"):
+            continue
+        picked.append(n)
+    if "ci" in picked and ci != "on":
+        others = len(picked) - 1
+        if ci == "off" or (others and others % ROW == 0):
+            picked.remove("ci")
+    colours = [catalogue[n][3] for n in picked]
+    for i, n in enumerate(picked):
+        if colours[i] != "contrast":
+            continue
+        neighbours = {colours[j] for j in (i - 1, i + 1) if 0 <= j < len(picked)}
+        neighbours |= {"blue"} if "default" in neighbours else set()  # shields' default reads blue
+        house = values.get("license_colour") or "orange"
+        colours[i] = house if house not in neighbours else next(
+            (c for c in CONTRAST if c not in neighbours), house)
+    lines = []
+    for n, colour in zip(picked, colours):
+        alt, image, link, _ = catalogue[n]
+        fill = {**values, "colour": colour}
+        lines.append(f"[![{alt.format(**fill)}]({image.format(**fill)})]({link.format(**fill)})")
+    return "\n".join(lines)
+
+
+def license_values(lid: Optional[str], spdx: Optional[str]) -> Dict[str, str]:
+    """The licence badge's text, link and house colour; empty when the project
+    has no catalogue licence (a file, none, or all rights reserved)."""
+    if not lid or not spdx or spdx.startswith("LicenseRef"):
+        return {}
+    label, url, colour = LICENSES.get(lid, (spdx, "LICENSE", "orange"))
+    return {"license_label": label, "license_badge": _shields_text(label), "license_url": url,
+            "license_colour": colour}