kctl-github 0.2.0__py3-none-any.whl

kctl_github/commands/config_cmd.py

@@ -0,0 +1,196 @@
+"""Config profile management commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+from kctl_github.core.config import (
+    SERVICE_KEY,
+    ServiceConfig,
+    get_all_services_in_profile,
+    get_profile_names,
+    get_service_config,
+    remove_profile,
+    resolve_active_profile_name,
+    set_default_profile,
+    set_service_config,
+)
+
+app = typer.Typer(help="Profile and configuration management.")
+
+
+@app.command()
+def init(ctx: typer.Context) -> None:
+    """Interactive config setup."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    profile_name = typer.prompt("Profile name", default="default")
+    token = typer.prompt("GitHub token (PAT)", default="", hide_input=True)
+    organization = typer.prompt("GitHub organization/user", default="tgunawandev")
+    repo_prefix = typer.prompt("Repository prefix filter", default="kodemeio-")
+    svc = ServiceConfig(token=token, organization=organization, repo_prefix=repo_prefix)
+    set_service_config(profile_name, svc)
+    set_default_profile(profile_name)
+    out.success(f"Config saved to profile '{profile_name}'")
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name")],
+) -> None:
+    """Add a new config profile."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    token = typer.prompt("GitHub token (PAT)", default="", hide_input=True)
+    organization = typer.prompt("GitHub organization/user", default="tgunawandev")
+    repo_prefix = typer.prompt("Repository prefix filter", default="kodemeio-")
+    svc = ServiceConfig(token=token, organization=organization, repo_prefix=repo_prefix)
+    set_service_config(name, svc)
+    out.success(f"Profile '{name}' added")
+
+
+@app.command()
+def use(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name to activate")],
+) -> None:
+    """Switch active config profile."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    available = get_profile_names()
+    if name not in available:
+        out.error(f"Profile '{name}' not found. Available: {', '.join(available)}")
+        raise typer.Exit(1)
+    set_default_profile(name)
+    out.success(f"Switched to profile '{name}'")
+
+
+@app.command()
+def show(ctx: typer.Context) -> None:
+    """Show current configuration."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    profiles = get_profile_names()
+    if out.json_mode:
+        out.raw_json({"active_profile": active, "profiles": {n: get_all_services_in_profile(n) for n in profiles}})
+        return
+    out.header("Configuration")
+    out.kv("Active profile", active)
+    for name in profiles:
+        marker = " (active)" if name == active else ""
+        out.header(f"Profile: {name}{marker}")
+        services = get_all_services_in_profile(name)
+        for svc_name, svc_data in services.items():
+            out.text(f"  [bold]{svc_name}:[/bold]")
+            if isinstance(svc_data, dict):
+                for k, v in svc_data.items():
+                    out.kv(f"    {k}", str(v))
+
+
+@app.command()
+def validate(ctx: typer.Context) -> None:
+    """Validate current config completeness."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    svc = get_service_config(active)
+    issues: list[str] = []
+    if not svc.token:
+        issues.append("token is not set")
+    if not svc.organization:
+        issues.append("organization is not set")
+    if out.json_mode:
+        out.raw_json({"profile": active, "valid": len(issues) == 0, "issues": issues})
+        return
+    if issues:
+        out.error(f"Profile '{active}' has {len(issues)} issue(s):")
+        for issue in issues:
+            out.text(f"  - {issue}")
+        raise typer.Exit(1)
+    out.success(f"Profile '{active}' is valid")
+
+
+@app.command()
+def remove(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name to remove")],
+) -> None:
+    """Remove a config profile."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    available = get_profile_names()
+    if name not in available:
+        out.error(f"Profile '{name}' not found")
+        raise typer.Exit(1)
+    remove_profile(name)
+    out.success(f"Profile '{name}' removed")
+
+
+@app.command("set")
+def set_(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config key")],
+    value: Annotated[str, typer.Argument(help="Config value")],
+) -> None:
+    """Set a single config value."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    svc = get_service_config(active)
+    if key not in ServiceConfig.model_fields:
+        out.error(f"Unknown key '{key}'. Valid: {', '.join(ServiceConfig.model_fields)}")
+        raise typer.Exit(1)
+    data = svc.model_dump()
+    data[key] = value
+    set_service_config(active, ServiceConfig(**data))
+    out.success(f"Set {key}={value} in profile '{active}'")
+
+
+@app.command()
+def profiles(ctx: typer.Context) -> None:
+    """List all config profiles."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    names = get_profile_names()
+    if out.json_mode:
+        out.raw_json({"profiles": names, "active": active})
+        return
+    rows = [[name, "active" if name == active else ""] for name in names]
+    out.table("Profiles", [("Name", "cyan"), ("Status", "green")], rows)
+
+
+@app.command()
+def current(ctx: typer.Context) -> None:
+    """Show active profile and resolved context."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    svc = get_service_config(active)
+    if out.json_mode:
+        out.raw_json({"profile": active, **svc.model_dump()})
+        return
+    fields = [(k, str(v) or "(not set)") for k, v in svc.model_dump().items()]
+    sections = [("Active Profile", [("Name", active)] + fields)]
+    out.detail("Current Config", sections)
+
+
+@app.command()
+def test(ctx: typer.Context) -> None:
+    """Test API connection with current configuration."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    active = resolve_active_profile_name(actx.profile)
+    out.info(f"Testing profile '{active}' \u2192 {SERVICE_KEY}")
+    try:
+        data = actx.client.get("/user")
+        login = data.get("login", "unknown")
+        out.success(f"Connected \u2014 authenticated as '{login}'")
+    except Exception as e:
+        out.error(f"Connection failed: {e}")
+        raise typer.Exit(1) from e

kctl_github/commands/dashboard.py

@@ -0,0 +1,89 @@
+"""Dashboard -- quick overview command."""
+
+from __future__ import annotations
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="Quick overview dashboard.")
+
+
+@app.callback(invoke_without_command=True)
+def dashboard(ctx: typer.Context) -> None:
+    """Show repos count, open PRs, failing CI, rate limits summary."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    # Get repos
+    repos = client.get_repos()
+    repo_count = len(repos)
+
+    # Count open PRs across repos
+    total_open_prs = 0
+    failing_ci = 0
+    for repo in repos:
+        name = repo["name"]
+        # Get open PRs
+        prs = client.get(
+            f"/repos/{client.organization}/{name}/pulls",
+            params={"state": "open", "per_page": 100},
+        )
+        if isinstance(prs, list):
+            total_open_prs += len(prs)
+
+        # Get latest workflow run
+        runs = client.get(
+            f"/repos/{client.organization}/{name}/actions/runs",
+            params={"per_page": 1},
+        )
+        workflow_runs = runs.get("workflow_runs", [])
+        if workflow_runs and workflow_runs[0].get("conclusion") == "failure":
+            failing_ci += 1
+
+    # Rate limits
+    rate = client.get("/rate_limit")
+    core = rate.get("resources", {}).get("core", {})
+
+    if out.json_mode:
+        out.raw_json(
+            {
+                "repos": repo_count,
+                "open_prs": total_open_prs,
+                "failing_ci": failing_ci,
+                "rate_limit_remaining": core.get("remaining"),
+            }
+        )
+        return
+
+    sections = [
+        (
+            "Repositories",
+            [
+                ("Total kodemeio-* repos", str(repo_count)),
+            ],
+        ),
+        (
+            "Pull Requests",
+            [
+                ("Open PRs (all repos)", str(total_open_prs)),
+            ],
+        ),
+        (
+            "CI/CD",
+            [
+                ("Repos with failing CI", str(failing_ci)),
+            ],
+        ),
+        (
+            "API",
+            [
+                ("Rate limit remaining", f"{core.get('remaining', '?')}/{core.get('limit', '?')}"),
+            ],
+        ),
+    ]
+    out.detail("GitHub Dashboard", sections)

kctl_github/commands/doctor_cmd.py

@@ -0,0 +1,82 @@
+"""Doctor diagnostic checks for kctl-github."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+from kctl_lib.doctor_base import CheckResult, DoctorCheck, run_doctor
+
+
+@dataclass
+class APIConnectivityCheck:
+    """Check that the configured GitHub organization is set."""
+
+    name: str = "API Connectivity"
+
+    def run(self) -> CheckResult:
+        try:
+            from kctl_github.core.config import get_service_config, resolve_active_profile_name
+
+            profile = resolve_active_profile_name()
+            cfg = get_service_config(profile)
+            org = cfg.organization or ""
+            if not org:
+                return CheckResult(
+                    name=self.name,
+                    status="fail",
+                    message="No organization configured",
+                    fix_command="kctl-github config init",
+                )
+            return CheckResult(name=self.name, status="ok", message=f"Organization: {org}")
+        except Exception as e:
+            return CheckResult(name=self.name, status="warn", message=str(e))
+
+
+@dataclass
+class AuthCheck:
+    """Check that authentication credentials are configured."""
+
+    name: str = "Authentication"
+
+    def run(self) -> CheckResult:
+        try:
+            from kctl_github.core.config import get_service_config, resolve_active_profile_name
+
+            profile = resolve_active_profile_name()
+            cfg = get_service_config(profile)
+            token = cfg.token or ""
+            if not token:
+                return CheckResult(
+                    name=self.name,
+                    status="fail",
+                    message="No GitHub token configured",
+                    fix_command="kctl-github config init",
+                )
+            masked = token[:4] + "****" + token[-4:] if len(token) > 8 else "****"
+            return CheckResult(name=self.name, status="ok", message=f"Token configured ({masked})")
+        except Exception as e:
+            return CheckResult(name=self.name, status="warn", message=str(e))
+
+
+app = typer.Typer(help="Run diagnostic checks.", no_args_is_help=False, invoke_without_command=True)
+
+
+@app.callback(invoke_without_command=True)
+def doctor(ctx: typer.Context) -> None:
+    """Run all diagnostic checks."""
+    if ctx.invoked_subcommand is not None:
+        return
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    checks: list[DoctorCheck] = [
+        APIConnectivityCheck(),
+        AuthCheck(),
+    ]
+
+    all_passed = run_doctor(checks, out)  # type: ignore[arg-type]
+    if not all_passed:
+        raise typer.Exit(code=1)

kctl_github/commands/health.py

@@ -0,0 +1,63 @@
+"""Health check commands."""
+
+from __future__ import annotations
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="API connectivity and rate limits.")
+
+
+@app.callback(invoke_without_command=True)
+def health(ctx: typer.Context) -> None:
+    """Check GitHub API reachability, rate limits, and token scopes."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    # Check rate limits
+    rate = client.get("/rate_limit")
+    core = rate.get("resources", {}).get("core", {})
+    search = rate.get("resources", {}).get("search", {})
+
+    # Get authenticated user info
+    user = client.get("/user")
+
+    if out.json_mode:
+        out.raw_json(
+            {
+                "status": "healthy",
+                "user": user.get("login"),
+                "rate_limit": {
+                    "core_remaining": core.get("remaining"),
+                    "core_limit": core.get("limit"),
+                    "search_remaining": search.get("remaining"),
+                    "search_limit": search.get("limit"),
+                },
+            }
+        )
+        return
+
+    out.success("GitHub API is reachable")
+    sections = [
+        (
+            "Connection",
+            [
+                ("User", user.get("login", "unknown")),
+                ("Name", user.get("name", "")),
+                ("Plan", user.get("plan", {}).get("name", "unknown")),
+            ],
+        ),
+        (
+            "Rate Limits",
+            [
+                ("Core", f"{core.get('remaining', '?')}/{core.get('limit', '?')}"),
+                ("Search", f"{search.get('remaining', '?')}/{search.get('limit', '?')}"),
+            ],
+        ),
+    ]
+    out.detail("GitHub Health", sections)

kctl_github/commands/labels.py

@@ -0,0 +1,131 @@
+"""Cross-repo label standardization."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="Cross-repo label management.")
+
+
+@app.command("list")
+def list_labels(
+    ctx: typer.Context,
+    repo: Annotated[str, typer.Argument(help="Repository name")],
+) -> None:
+    """List labels for a repo."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    labels = client.get(f"/repos/{owner}/{repo}/labels", params={"per_page": 100})
+
+    if out.json_mode:
+        out.raw_json(
+            [
+                {
+                    "name": label["name"],
+                    "color": label.get("color", ""),
+                    "description": label.get("description", ""),
+                }
+                for label in labels
+            ]
+        )
+        return
+
+    rows = [[label["name"], f"#{label.get('color', '')}", label.get("description", "") or ""] for label in labels]
+    out.table(
+        f"Labels: {repo}",
+        [("Name", "cyan"), ("Color", "yellow"), ("Description", "")],
+        rows,
+    )
+
+
+@app.command()
+def sync(
+    ctx: typer.Context,
+    source: Annotated[str, typer.Option("--source", "-s", help="Source repo to copy labels from")],
+) -> None:
+    """Copy labels from source repo to all other kodemeio-* repos."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    # Get source labels
+    source_labels = client.get(f"/repos/{owner}/{source}/labels", params={"per_page": 100})
+    if not isinstance(source_labels, list):
+        out.error("Failed to fetch source labels")
+        raise typer.Exit(1)
+
+    repos = client.get_repos()
+    target_repos = [r for r in repos if r["name"] != source]
+
+    for repo in target_repos:
+        name = repo["name"]
+        existing = client.get(f"/repos/{owner}/{name}/labels", params={"per_page": 100})
+        existing_names = {label["name"] for label in existing} if isinstance(existing, list) else set()
+
+        created = 0
+        for label in source_labels:
+            if label["name"] not in existing_names:
+                try:
+                    client.post(
+                        f"/repos/{owner}/{name}/labels",
+                        json={
+                            "name": label["name"],
+                            "color": label.get("color", "000000"),
+                            "description": label.get("description", ""),
+                        },
+                    )
+                    created += 1
+                except Exception:  # noqa: BLE001
+                    pass  # Label may already exist with different casing
+
+        if created > 0:
+            out.success(f"{name}: added {created} label(s)")
+        else:
+            out.info(f"{name}: already in sync")
+
+
+@app.command()
+def diff(ctx: typer.Context) -> None:
+    """Show label differences across repos."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    repos = client.get_repos()
+    all_labels: set[str] = set()
+    repo_labels: dict[str, set[str]] = {}
+
+    for repo in repos:
+        name = repo["name"]
+        labels = client.get(f"/repos/{owner}/{name}/labels", params={"per_page": 100})
+        label_names = {label["name"] for label in labels} if isinstance(labels, list) else set()
+        all_labels.update(label_names)
+        repo_labels[name] = label_names
+
+    sorted_labels = sorted(all_labels)
+
+    if out.json_mode:
+        out.raw_json({repo: sorted(names) for repo, names in repo_labels.items()})
+        return
+
+    columns: list[tuple[str, str]] = [("Label", "cyan")]
+    sorted_repos = sorted(repo_labels.keys())
+    columns.extend((r.removeprefix("kodemeio-")[:12], "") for r in sorted_repos)
+
+    rows = []
+    for label in sorted_labels:
+        row = [label]
+        for repo_name in sorted_repos:
+            row.append("Y" if label in repo_labels[repo_name] else "-")
+        rows.append(row)
+
+    out.table("Label Diff", columns, rows)