kctl-github 0.2.0__py3-none-any.whl

kctl_github/commands/stats.py

@@ -0,0 +1,208 @@
+"""Repository statistics commands."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="Repository statistics across kodemeio-* repos.")
+
+
+@app.command()
+def overview(ctx: typer.Context) -> None:
+    """Total repos, total stars, total issues, total PRs."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+    total_stars = sum(r.get("stargazers_count", 0) for r in repos)
+    total_forks = sum(r.get("forks_count", 0) for r in repos)
+    total_issues = sum(r.get("open_issues_count", 0) for r in repos)
+    total_size = sum(r.get("size", 0) for r in repos)
+
+    if out.json_mode:
+        out.raw_json(
+            {
+                "repos": len(repos),
+                "stars": total_stars,
+                "forks": total_forks,
+                "open_issues": total_issues,
+                "total_size_kb": total_size,
+            }
+        )
+        return
+
+    sections = [
+        (
+            "Overview",
+            [
+                ("Repositories", str(len(repos))),
+                ("Total Stars", str(total_stars)),
+                ("Total Forks", str(total_forks)),
+                ("Open Issues", str(total_issues)),
+                ("Total Size", f"{total_size:,} KB ({total_size // 1024} MB)"),
+            ],
+        ),
+    ]
+    out.detail("GitHub Stats Overview", sections)
+
+
+@app.command()
+def activity(
+    ctx: typer.Context,
+    period: Annotated[str, typer.Option("--period", help="Time period (e.g., 7d, 30d)")] = "30d",
+) -> None:
+    """Commit activity, PR merge rate, issue velocity."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    days = int(period.rstrip("d"))
+    since = datetime.now(UTC) - timedelta(days=days)
+    since_str = since.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    repos = client.get_repos()
+    rows = []
+
+    for repo in sorted(repos, key=lambda x: x["name"]):
+        name = repo["name"]
+        owner = client.organization
+
+        # Commits since period
+        try:
+            commits = client.get(
+                f"/repos/{owner}/{name}/commits",
+                params={"since": since_str, "per_page": 100},
+            )
+            commit_count = len(commits) if isinstance(commits, list) else 0
+        except Exception:  # noqa: BLE001
+            commit_count = 0
+
+        # Merged PRs in period
+        try:
+            prs = client.get(
+                f"/repos/{owner}/{name}/pulls",
+                params={"state": "closed", "sort": "updated", "direction": "desc", "per_page": 50},
+            )
+            merged_count = 0
+            if isinstance(prs, list):
+                for pr in prs:
+                    if pr.get("merged_at"):
+                        try:
+                            merged_dt = datetime.fromisoformat(pr["merged_at"].replace("Z", "+00:00"))
+                            if merged_dt >= since:
+                                merged_count += 1
+                        except (ValueError, TypeError):
+                            pass
+        except Exception:  # noqa: BLE001
+            merged_count = 0
+
+        if commit_count > 0 or merged_count > 0:
+            rows.append([name, str(commit_count), str(merged_count)])
+
+    if out.json_mode:
+        out.raw_json(
+            [
+                {
+                    "repo": r[0],
+                    "commits": int(r[1]),
+                    "merged_prs": int(r[2]),
+                }
+                for r in rows
+            ]
+        )
+        return
+
+    out.table(
+        f"Activity (last {days} days)",
+        [("Repo", "cyan"), ("Commits", "green"), ("Merged PRs", "yellow")],
+        rows,
+    )
+
+
+@app.command()
+def languages(ctx: typer.Context) -> None:
+    """Language breakdown across all repos."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+    lang_totals: dict[str, int] = {}
+
+    for repo in repos:
+        name = repo["name"]
+        try:
+            langs = client.get(f"/repos/{client.organization}/{name}/languages")
+            if isinstance(langs, dict):
+                for lang, bytes_count in langs.items():
+                    lang_totals[lang] = lang_totals.get(lang, 0) + bytes_count
+        except Exception:  # noqa: BLE001
+            pass
+
+    total = sum(lang_totals.values())
+    sorted_langs = sorted(lang_totals.items(), key=lambda x: x[1], reverse=True)
+
+    if out.json_mode:
+        out.raw_json(
+            {
+                lang: {"bytes": b, "percentage": f"{(b / total * 100):.1f}%"} if total else {"bytes": b}
+                for lang, b in sorted_langs
+            }
+        )
+        return
+
+    rows = []
+    for lang, bytes_count in sorted_langs[:20]:
+        pct = (bytes_count / total * 100) if total else 0
+        bar = "#" * int(pct / 2)
+        rows.append([lang, f"{bytes_count:,}", f"{pct:.1f}%", bar])
+
+    out.table(
+        "Languages (all repos)",
+        [("Language", "cyan"), ("Bytes", ""), ("%", "yellow"), ("Distribution", "green")],
+        rows,
+    )
+
+
+@app.command()
+def contributors(ctx: typer.Context) -> None:
+    """Contributor activity across all repos."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+    contributor_totals: dict[str, int] = {}
+
+    for repo in repos:
+        name = repo["name"]
+        try:
+            contribs = client.get(
+                f"/repos/{client.organization}/{name}/contributors",
+                params={"per_page": 30},
+            )
+            if isinstance(contribs, list):
+                for c in contribs:
+                    login = c.get("login", "unknown")
+                    contributor_totals[login] = contributor_totals.get(login, 0) + c.get("contributions", 0)
+        except Exception:  # noqa: BLE001
+            pass
+
+    sorted_contribs = sorted(contributor_totals.items(), key=lambda x: x[1], reverse=True)
+
+    if out.json_mode:
+        out.raw_json([{"login": login, "total_contributions": count} for login, count in sorted_contribs])
+        return
+
+    rows = [[login, str(count)] for login, count in sorted_contribs[:20]]
+    out.table(
+        "Top Contributors (all repos)",
+        [("Login", "cyan"), ("Total Contributions", "yellow")],
+        rows,
+    )

kctl_github/core/callbacks.py

@@ -0,0 +1,40 @@
+"""Application context for kctl-github."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from kctl_lib.callbacks import AppContextBase
+
+from kctl_github.core.client import GitHubClient
+from kctl_github.core.config import (
+    ServiceConfig,
+    get_service_config,
+    resolve_active_profile_name,
+)
+
+
+@dataclass
+class AppContext(AppContextBase):
+    """kctl-github application context."""
+
+    _client: GitHubClient | None = field(default=None, repr=False)
+
+    @property
+    def client(self) -> GitHubClient:
+        """Lazy-initialize GitHub API client from active profile config."""
+        if self._client is None:
+            profile = resolve_active_profile_name(self.profile)
+            cfg = get_service_config(profile)
+            self._client = GitHubClient(
+                credential=cfg.token,
+                organization=cfg.organization,
+                repo_prefix=cfg.repo_prefix,
+            )
+        return self._client
+
+    @property
+    def config(self) -> ServiceConfig:
+        """Get the resolved service config."""
+        profile = resolve_active_profile_name(self.profile)
+        return get_service_config(profile)

kctl_github/core/client.py

@@ -0,0 +1,124 @@
+"""GitHub API client and gh CLI helper."""
+
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+from kctl_lib.api_client import APIClient
+from kctl_lib.runner import run
+
+
+class GitHubClient(APIClient):
+    """Synchronous GitHub REST API client.
+
+    Subclasses APIClient with GitHub-specific defaults.
+    Provides helpers for paginated listing and repo filtering.
+    """
+
+    BASE_URL = "https://api.github.com"
+    AUTH_HEADER = "Authorization"
+    AUTH_PREFIX = "Bearer"
+
+    def __init__(
+        self,
+        credential: str = "",
+        organization: str = "tgunawandev",
+        repo_prefix: str = "kodemeio-",
+        timeout: float = 30.0,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(credential=credential, timeout=timeout, **kwargs)
+        self._organization = organization
+        self._repo_prefix = repo_prefix
+        # Add Accept header for GitHub API v3
+        self._client.headers["Accept"] = "application/vnd.github+json"
+        self._client.headers["X-GitHub-Api-Version"] = "2022-11-28"
+
+    # ------------------------------------------------------------------
+    # Pagination helper
+    # ------------------------------------------------------------------
+
+    def get_paginated(
+        self,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        max_pages: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Fetch all pages from a paginated GitHub endpoint.
+
+        GitHub uses Link headers for pagination. This method follows
+        ``next`` links up to *max_pages*.
+        """
+        all_items: list[dict[str, Any]] = []
+        _params = dict(params or {})
+        _params.setdefault("per_page", 100)
+
+        for _ in range(max_pages):
+            response = self._request("GET", endpoint, params=_params)
+            data = response.json()
+            if isinstance(data, list):
+                all_items.extend(data)
+            else:
+                # Some endpoints return objects with items inside
+                break
+
+            # Check for next page via Link header
+            link = response.headers.get("link", "")
+            if 'rel="next"' not in link:
+                break
+
+            # Parse next URL from Link header
+            next_url = _parse_next_link(link)
+            if not next_url:
+                break
+
+            # Extract query params from the next URL for subsequent request
+            parsed = urlparse(next_url)
+            _params = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+
+        return all_items
+
+    # ------------------------------------------------------------------
+    # Repo helpers
+    # ------------------------------------------------------------------
+
+    def get_repos(self) -> list[dict[str, Any]]:
+        """Get all repos matching the configured prefix."""
+        repos = self.get_paginated(f"/users/{self._organization}/repos")
+        return [r for r in repos if r.get("name", "").startswith(self._repo_prefix)]
+
+    def get_repo(self, name: str) -> dict[str, Any]:
+        """Get a single repo by name (short name, not full_name)."""
+        return self.get(f"/repos/{self._organization}/{name}")
+
+    @property
+    def organization(self) -> str:
+        return self._organization
+
+    @property
+    def repo_prefix(self) -> str:
+        return self._repo_prefix
+
+
+def _parse_next_link(link_header: str) -> str | None:
+    """Parse the 'next' URL from a GitHub Link header."""
+    for part in link_header.split(","):
+        if 'rel="next"' in part:
+            url = part.split(";")[0].strip().strip("<>")
+            return url
+    return None
+
+
+def gh_run(args: list[str], check: bool = True) -> str:
+    """Run a gh CLI command and return stdout.
+
+    Args:
+        args: Arguments to pass to ``gh`` (e.g., ["pr", "view", "123"]).
+        check: If True, raise CommandError on non-zero exit.
+
+    Returns:
+        The stdout output as a string.
+    """
+    result = run(["gh", *args], check=check)
+    return result.stdout.strip()

kctl_github/core/config.py

@@ -0,0 +1,55 @@
+"""Config management for kctl-github."""
+
+from __future__ import annotations
+
+from kctl_lib.config import (
+    get_all_services_in_profile,
+    get_profile_names,
+    remove_profile,
+    set_default_profile,
+)
+from kctl_lib.config import get_service_config as _get_service_config
+from kctl_lib.config import (
+    resolve_active_profile_name as _resolve_active_profile_name,
+)
+from kctl_lib.config import set_service_config as _set_service_config
+from pydantic import BaseModel
+
+__all__ = [
+    "ServiceConfig",
+    "get_all_services_in_profile",
+    "get_profile_names",
+    "get_service_config",
+    "remove_profile",
+    "resolve_active_profile_name",
+    "set_default_profile",
+    "set_service_config",
+]
+
+SERVICE_KEY = "github"
+ENV_PREFIX = "KCTL_GITHUB"
+
+
+class ServiceConfig(BaseModel):
+    """Service-specific config within a profile."""
+
+    token: str = ""  # GitHub Personal Access Token
+    organization: str = "tgunawandev"  # GitHub org or username
+    repo_prefix: str = "kodemeio-"  # Filter repos by this prefix
+
+
+def get_service_config(profile_name: str) -> ServiceConfig:
+    """Get the 'github' service config from a profile."""
+    data = _get_service_config(profile_name, SERVICE_KEY, list(ServiceConfig.model_fields.keys()))
+    return ServiceConfig(**data) if data else ServiceConfig()
+
+
+def set_service_config(profile_name: str, svc_config: ServiceConfig) -> None:
+    """Set the 'github' service config within a profile."""
+    cleaned = {k: v for k, v in svc_config.model_dump().items() if v}
+    _set_service_config(profile_name, SERVICE_KEY, cleaned)
+
+
+def resolve_active_profile_name(profile_name: str | None = None) -> str:
+    """Resolve active profile: explicit > env > default."""
+    return _resolve_active_profile_name(profile_name, ENV_PREFIX)

kctl_github/core/exceptions.py

@@ -0,0 +1,21 @@
+"""Exception hierarchy -- re-exported from kctl-lib."""
+
+from kctl_lib.exceptions import (
+    APIError,
+    AuthenticationError,
+    CommandError,
+    ConfigError,
+    KctlError,
+    NotFoundError,
+)
+from kctl_lib.exceptions import ConnectionError as KctlConnectionError
+
+__all__ = [
+    "APIError",
+    "AuthenticationError",
+    "CommandError",
+    "ConfigError",
+    "KctlConnectionError",
+    "KctlError",
+    "NotFoundError",
+]

kctl_github/core/plugins.py

@@ -0,0 +1,13 @@
+"""Plugin discovery for kctl-github."""
+
+from kctl_lib.plugins import KctlPlugin
+from kctl_lib.plugins import discover_and_load_plugins as _discover
+
+__all__ = ["KctlPlugin", "discover_and_load_plugins"]
+
+ENTRY_POINT_GROUP = "kctl_github.plugins"
+
+
+def discover_and_load_plugins(app):  # noqa: ANN001, ANN201
+    """Discover and load kctl-github plugins."""
+    return _discover(app, ENTRY_POINT_GROUP)

kctl_github-0.2.0.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: kctl-github
+Version: 0.2.0
+Summary: Kodemeio GitHub CLI — cross-repo GitHub management
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: kctl-lib>=0.4.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=13.9.0
+Requires-Dist: typer>=0.15.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.14.0; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.35.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.9.0; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'

kctl_github-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+kctl_github/__init__.py,sha256=ssQ8gwlDUUPmKmQR0Dgl3Cq9sAapzcRw7tLy-dOKfk4,73
+kctl_github/__main__.py,sha256=zu0zAIML3odZ6Gfhdi8aZns3cMwzXTcNPd8OpE6PrU4,88
+kctl_github/cli.py,sha256=EgSieOmkYLPZQP2R7U53_LSLR08sI95toYVtc78Q6qY,4506
+kctl_github/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kctl_github/commands/billing.py,sha256=7JP9xcMMRrcCDEKVcGMYtaTkbkE_se2shffNYr5J0Lw,5514
+kctl_github/commands/ci.py,sha256=Z8evyvPI2m5AInQvoHwPZIOAw8BO0aDGX-qkS1XLxTA,8419
+kctl_github/commands/config_cmd.py,sha256=-Q9Kl2SVctAPOLpsr0RnD3DvFO-GbDbJ7wOAX_ieTwU,6644
+kctl_github/commands/dashboard.py,sha256=ZTsxtiw_WiLr-0oGRAPV7zHd4aFtWcdqWOD9Xg2S9mY,2318
+kctl_github/commands/doctor_cmd.py,sha256=nKTOsNMr3wQMqdsSlbnzkd8HGEfwJu1du6ZteLzEBNQ,2667
+kctl_github/commands/health.py,sha256=2DXKQvTBfGH9OdwGrin5b5uHOej2BESlA6mv_9mqTbU,1799
+kctl_github/commands/labels.py,sha256=fNwPmdFdznEY2TzW20yb6WMPpTvj3V81bxzjvMl-kpE,4128
+kctl_github/commands/prs.py,sha256=FjISEt6pfpypP1xJEnfHcsADffveC3UyTUcIi_gfP3k,4962
+kctl_github/commands/repos.py,sha256=8X4N1XuRY9Z1GLRf2dcuI-IKrn-vlN1tigFimpSBHqs,5769
+kctl_github/commands/secrets.py,sha256=9v7yDyHwyPVj3P9M8zdcTsrA_pPWaDrQwAJtG0FVA4k,4157
+kctl_github/commands/skill_cmd.py,sha256=96_A2tOt7rlhA6FCNOp8bwRdLgveX6ON4xwD8vhrNJE,2434
+kctl_github/commands/stats.py,sha256=uckK6hm5kv1JRxxY90RNRDmWLtYqw5EnqcW6lWJ02s4,6419
+kctl_github/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kctl_github/core/callbacks.py,sha256=C9KzkKnksZfJesCsVbLpkSSyURxPKvM-ZQJI8IvMp0s,1181
+kctl_github/core/client.py,sha256=lDhRr8ThNtVJIRdEskVuNA8X7zP-4jhwCwm5CHuPQQg,4045
+kctl_github/core/config.py,sha256=Sul8rP_hfTi-5o-x3kTbAeIi9YMYEDWQQeUE6XQ6kPQ,1783
+kctl_github/core/exceptions.py,sha256=zt41Q5YfY01BdNJRLLwoTmlosJBceNioqwAWBIuzE8M,434
+kctl_github/core/plugins.py,sha256=L-AJBFVVhlu1pxztAGnIGCzx0OY4x4Wnre0OEEgUqM4,403
+kctl_github-0.2.0.dist-info/METADATA,sha256=-qmWuYp18TqN--5EKfsUlV4kbuoVlW0EwHeKm1EhiaY,574
+kctl_github-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+kctl_github-0.2.0.dist-info/entry_points.txt,sha256=-5NGnCyq0nyeojwI-_lyg4ZRw3ZIEQdSJrRyarPrWSk,53
+kctl_github-0.2.0.dist-info/RECORD,,

kctl_github-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

kctl_github-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kctl-github = kctl_github.cli:_run