kctl-github 0.2.0__py3-none-any.whl

kctl_github/commands/prs.py

@@ -0,0 +1,161 @@
+"""Cross-repo pull request management."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime, timedelta
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+from kctl_github.core.client import gh_run
+
+app = typer.Typer(help="Cross-repo PR management.")
+
+
+@app.command("list")
+def list_prs(ctx: typer.Context) -> None:
+    """Open PRs across all kodemeio-* repos."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+    all_prs = []
+
+    for repo in repos:
+        name = repo["name"]
+        prs = client.get(
+            f"/repos/{client.organization}/{name}/pulls",
+            params={"state": "open", "per_page": 100},
+        )
+        if isinstance(prs, list):
+            for pr in prs:
+                all_prs.append(
+                    {
+                        "repo": name,
+                        "number": pr["number"],
+                        "title": pr["title"],
+                        "author": pr.get("user", {}).get("login", ""),
+                        "created_at": pr.get("created_at", ""),
+                        "draft": pr.get("draft", False),
+                        "labels": [label["name"] for label in pr.get("labels", [])],
+                    }
+                )
+
+    if out.json_mode:
+        out.raw_json(all_prs)
+        return
+
+    rows = []
+    for pr in sorted(all_prs, key=lambda x: x["created_at"], reverse=True):
+        draft_marker = " (draft)" if pr["draft"] else ""
+        rows.append(
+            [
+                pr["repo"],
+                f"#{pr['number']}",
+                pr["title"][:60] + draft_marker,
+                pr["author"],
+                pr["created_at"][:10],
+            ]
+        )
+
+    out.table(
+        f"Open Pull Requests ({len(rows)} total)",
+        [("Repo", "cyan"), ("#", ""), ("Title", ""), ("Author", "yellow"), ("Created", "")],
+        rows,
+    )
+
+
+@app.command()
+def show(
+    ctx: typer.Context,
+    repo: Annotated[str, typer.Argument(help="Repository name")],
+    number: Annotated[int, typer.Argument(help="PR number")],
+) -> None:
+    """Show PR details (delegates to gh pr view)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    owner = actx.client.organization
+
+    if out.json_mode:
+        result = gh_run(
+            [
+                "pr",
+                "view",
+                str(number),
+                "--repo",
+                f"{owner}/{repo}",
+                "--json",
+                "title,body,state,author,createdAt,mergeable,reviews,labels",
+            ]
+        )
+        out.raw_json(json.loads(result))
+        return
+
+    result = gh_run(["pr", "view", str(number), "--repo", f"{owner}/{repo}"])
+    out.text(result)
+
+
+@app.command()
+def stale(
+    ctx: typer.Context,
+    days: Annotated[int, typer.Option("--days", "-d", help="Days without activity")] = 14,
+) -> None:
+    """Find PRs with no activity for N days."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    cutoff = datetime.now(UTC) - timedelta(days=days)
+    repos = client.get_repos()
+    stale_prs: list[dict[str, str | int]] = []
+
+    for repo in repos:
+        name = repo["name"]
+        prs = client.get(
+            f"/repos/{client.organization}/{name}/pulls",
+            params={"state": "open", "per_page": 100, "sort": "updated", "direction": "asc"},
+        )
+        if isinstance(prs, list):
+            for pr in prs:
+                updated = pr.get("updated_at", "")
+                if updated:
+                    try:
+                        updated_dt = datetime.fromisoformat(updated.replace("Z", "+00:00"))
+                        if updated_dt < cutoff:
+                            stale_prs.append(
+                                {
+                                    "repo": name,
+                                    "number": pr["number"],
+                                    "title": pr["title"],
+                                    "author": pr.get("user", {}).get("login", ""),
+                                    "updated_at": updated[:10],
+                                    "days_stale": (datetime.now(UTC) - updated_dt).days,
+                                }
+                            )
+                    except (ValueError, TypeError):
+                        pass
+
+    if out.json_mode:
+        out.raw_json(stale_prs)
+        return
+
+    rows = [
+        [
+            str(p["repo"]),
+            f"#{p['number']}",
+            str(p["title"])[:50],
+            str(p["author"]),
+            str(p["updated_at"]),
+            f"{p['days_stale']}d",
+        ]
+        for p in sorted(stale_prs, key=lambda x: int(x["days_stale"]), reverse=True)
+    ]
+
+    out.table(
+        f"Stale PRs (no activity for {days}+ days)",
+        [("Repo", "cyan"), ("#", ""), ("Title", ""), ("Author", "yellow"), ("Last Update", ""), ("Stale", "red")],
+        rows,
+    )

kctl_github/commands/repos.py

@@ -0,0 +1,179 @@
+"""Cross-repo overview commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="Cross-repo overview for kodemeio-* repositories.")
+
+
+@app.command("list")
+def list_repos(ctx: typer.Context) -> None:
+    """List all kodemeio-* repos with visibility, default branch, last push."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+
+    if out.json_mode:
+        out.raw_json(
+            [
+                {
+                    "name": r["name"],
+                    "visibility": "private" if r.get("private") else "public",
+                    "default_branch": r.get("default_branch", "main"),
+                    "pushed_at": r.get("pushed_at", ""),
+                    "description": r.get("description", ""),
+                }
+                for r in repos
+            ]
+        )
+        return
+
+    rows = []
+    for r in sorted(repos, key=lambda x: x["name"]):
+        rows.append(
+            [
+                r["name"],
+                "private" if r.get("private") else "public",
+                r.get("default_branch", "main"),
+                _format_date(r.get("pushed_at", "")),
+            ]
+        )
+
+    out.table(
+        f"Repositories ({len(rows)} matching '{client.repo_prefix}*')",
+        [("Name", "cyan"), ("Visibility", ""), ("Branch", ""), ("Last Push", "yellow")],
+        rows,
+    )
+
+
+@app.command()
+def status(ctx: typer.Context) -> None:
+    """Aggregated status: open PRs, failing CI, stale branches per repo."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+
+    repos = client.get_repos()
+    rows = []
+
+    for repo in sorted(repos, key=lambda x: x["name"]):
+        name = repo["name"]
+        owner = client.organization
+
+        # Open PRs count
+        prs = client.get(f"/repos/{owner}/{name}/pulls", params={"state": "open", "per_page": 100})
+        pr_count = len(prs) if isinstance(prs, list) else 0
+
+        # Latest CI status
+        runs = client.get(f"/repos/{owner}/{name}/actions/runs", params={"per_page": 1})
+        workflow_runs = runs.get("workflow_runs", [])
+        if workflow_runs:
+            ci_status = workflow_runs[0].get("conclusion") or workflow_runs[0].get("status", "unknown")
+        else:
+            ci_status = "none"
+
+        # Branch count
+        branches = client.get(f"/repos/{owner}/{name}/branches", params={"per_page": 100})
+        branch_count = len(branches) if isinstance(branches, list) else 0
+
+        rows.append([name, str(pr_count), ci_status, str(branch_count)])
+
+    if out.json_mode:
+        out.raw_json(
+            [
+                {
+                    "repo": r[0],
+                    "open_prs": int(r[1]),
+                    "ci_status": r[2],
+                    "branches": int(r[3]),
+                }
+                for r in rows
+            ]
+        )
+        return
+
+    out.table(
+        "Repository Status",
+        [("Repo", "cyan"), ("Open PRs", "yellow"), ("CI", "green"), ("Branches", "")],
+        rows,
+    )
+
+
+@app.command()
+def show(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Repository name (e.g., kodemeio-next)")],
+) -> None:
+    """Show single repo details (size, languages, contributors)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    repo = client.get_repo(name)
+    languages = client.get(f"/repos/{owner}/{name}/languages")
+    contributors = client.get(f"/repos/{owner}/{name}/contributors", params={"per_page": 10})
+
+    if out.json_mode:
+        out.raw_json(
+            {
+                "name": repo["name"],
+                "description": repo.get("description", ""),
+                "size_kb": repo.get("size", 0),
+                "default_branch": repo.get("default_branch"),
+                "languages": languages,
+                "top_contributors": [
+                    {"login": c["login"], "contributions": c["contributions"]}
+                    for c in (contributors if isinstance(contributors, list) else [])[:5]
+                ],
+            }
+        )
+        return
+
+    total_bytes = sum(languages.values()) if isinstance(languages, dict) else 0
+    lang_lines = []
+    if isinstance(languages, dict):
+        for lang, bytes_count in sorted(languages.items(), key=lambda x: x[1], reverse=True)[:5]:
+            pct = (bytes_count / total_bytes * 100) if total_bytes else 0
+            lang_lines.append((lang, f"{pct:.1f}%"))
+
+    contrib_lines = []
+    if isinstance(contributors, list):
+        for c in contributors[:5]:
+            contrib_lines.append((c["login"], f"{c['contributions']} commits"))
+
+    sections = [
+        (
+            "Repository",
+            [
+                ("Name", repo["name"]),
+                ("Description", repo.get("description") or "(none)"),
+                ("Visibility", "private" if repo.get("private") else "public"),
+                ("Default Branch", repo.get("default_branch", "main")),
+                ("Size", f"{repo.get('size', 0)} KB"),
+                ("Open Issues", str(repo.get("open_issues_count", 0))),
+                ("Created", _format_date(repo.get("created_at", ""))),
+                ("Last Push", _format_date(repo.get("pushed_at", ""))),
+            ],
+        ),
+        ("Languages (top 5)", lang_lines),
+        ("Contributors (top 5)", contrib_lines),
+    ]
+    out.detail(f"Repository: {name}", sections)
+
+
+def _format_date(iso_date: str) -> str:
+    """Format an ISO date string to a shorter readable format."""
+    if not iso_date:
+        return ""
+    try:
+        return iso_date[:10]
+    except Exception:
+        return iso_date

kctl_github/commands/secrets.py

@@ -0,0 +1,132 @@
+"""Cross-repo secret management."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+from kctl_github.core.client import gh_run
+
+app = typer.Typer(help="Cross-repo Actions secret management.")
+
+
+@app.command("list")
+def list_secrets(
+    ctx: typer.Context,
+    repo: Annotated[str, typer.Argument(help="Repository name")],
+) -> None:
+    """List Actions secrets for a repo."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    data = client.get(f"/repos/{owner}/{repo}/actions/secrets")
+    secrets = data.get("secrets", [])
+
+    if out.json_mode:
+        out.raw_json([{"name": s["name"], "updated_at": s.get("updated_at", "")} for s in secrets])
+        return
+
+    rows = [[s["name"], s.get("updated_at", "")[:10]] for s in secrets]
+    out.table(
+        f"Secrets: {repo}",
+        [("Name", "cyan"), ("Last Updated", "yellow")],
+        rows,
+    )
+
+
+@app.command()
+def audit(ctx: typer.Context) -> None:
+    """Check which repos have which secrets (matrix view)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    repos = client.get_repos()
+    all_secret_names: set[str] = set()
+    repo_secrets: dict[str, set[str]] = {}
+
+    for repo in repos:
+        name = repo["name"]
+        try:
+            data = client.get(f"/repos/{owner}/{name}/actions/secrets")
+            secrets = data.get("secrets", [])
+            secret_names = {s["name"] for s in secrets}
+            all_secret_names.update(secret_names)
+            repo_secrets[name] = secret_names
+        except Exception:  # noqa: BLE001
+            repo_secrets[name] = set()
+
+    sorted_secrets = sorted(all_secret_names)
+
+    if out.json_mode:
+        out.raw_json({repo: [s for s in sorted_secrets if s in secs] for repo, secs in repo_secrets.items()})
+        return
+
+    columns: list[tuple[str, str]] = [("Repo", "cyan")]
+    columns.extend((s, "") for s in sorted_secrets)
+
+    rows = []
+    for repo_name in sorted(repo_secrets.keys()):
+        row = [repo_name]
+        for secret in sorted_secrets:
+            row.append("Y" if secret in repo_secrets[repo_name] else "-")
+        rows.append(row)
+
+    out.table("Secrets Audit", columns, rows)
+
+
+@app.command("set")
+def set_secret(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Secret name")],
+    repos: Annotated[str, typer.Option("--repos", "-r", help="Comma-separated repo names")],
+) -> None:
+    """Set a secret across multiple repos (prompts for value)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    owner = actx.client.organization
+
+    value = typer.prompt(f"Secret value for {name}", hide_input=True)
+    repo_list = [r.strip() for r in repos.split(",")]
+
+    for repo in repo_list:
+        try:
+            gh_run(["secret", "set", name, "--repo", f"{owner}/{repo}", "--body", value])
+            out.success(f"Set {name} in {repo}")
+        except Exception as e:  # noqa: BLE001
+            out.error(f"Failed to set {name} in {repo}: {e}")
+
+
+@app.command()
+def rotate(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Secret name to rotate")],
+) -> None:
+    """Update a secret across all repos that have it."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    client = actx.client
+    owner = client.organization
+
+    value = typer.prompt(f"New value for {name}", hide_input=True)
+    repos = client.get_repos()
+    updated = 0
+
+    for repo in repos:
+        repo_name = repo["name"]
+        try:
+            data = client.get(f"/repos/{owner}/{repo_name}/actions/secrets")
+            secret_names = {s["name"] for s in data.get("secrets", [])}
+            if name in secret_names:
+                gh_run(["secret", "set", name, "--repo", f"{owner}/{repo_name}", "--body", value])
+                out.success(f"Rotated {name} in {repo_name}")
+                updated += 1
+        except Exception as e:  # noqa: BLE001
+            out.error(f"Failed for {repo_name}: {e}")
+
+    out.info(f"Rotated {name} in {updated} repo(s)")

kctl_github/commands/skill_cmd.py

@@ -0,0 +1,76 @@
+"""Skill generation for Claude Code integration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from kctl_github.core.callbacks import AppContext
+
+app = typer.Typer(help="Claude Code skill management.")
+
+
+@app.command()
+def generate(
+    ctx: typer.Context,
+    output: Annotated[str, typer.Option("--output", "-o", help="Output directory")] = "",
+    install: Annotated[bool, typer.Option("--install", help="Install to ~/.claude/skills/")] = False,
+    check: Annotated[bool, typer.Option("--check", help="Check if SKILL.md is stale (exit 1 if stale)")] = False,
+) -> None:
+    """Auto-generate SKILL.md from CLI command registry.
+
+    Examples:
+        kctl-github skill generate
+        kctl-github skill generate --install
+        kctl-github skill generate --check
+    """
+    actx: AppContext = ctx.obj
+    out = actx.output
+    from kctl_lib.skill_generator import check_stale, generate_skill
+
+    from kctl_github.cli import app as cli_app
+
+    skill_name = "github-admin"
+    description = "GitHub cross-repo management via kctl-github CLI"
+
+    # Canonical in-repo skill dir — source of SKILL.extra.md regardless
+    # of where output goes. Without this, --install writes to
+    # ~/.claude/skills/ and the handwritten runbook vanishes.
+    cli_root = Path(__file__).resolve().parents[3]
+    source_dir = cli_root / "skills" / skill_name
+
+    # Determine output directory
+    if output:
+        output_dir = Path(output)
+    elif install:
+        output_dir = Path.home() / ".claude" / "skills" / skill_name
+    else:
+        output_dir = source_dir
+
+    # Check-only mode
+    if check:
+        skill_file = output_dir / "SKILL.md"
+        is_stale, reason = check_stale(cli_app, skill_file)
+        if is_stale:
+            out.warn(f"SKILL.md is stale: {reason}")
+            out.info("Run: kctl-github skill generate")
+            raise typer.Exit(1)
+        out.success(f"SKILL.md is up to date: {reason}")
+        return
+
+    # Extra content always lives at the in-repo location.
+    extra = source_dir / "SKILL.extra.md"
+
+    generate_skill(
+        cli_app,
+        "kctl-github",
+        skill_name,
+        description,
+        output_dir=output_dir,
+        extra_file=extra if extra.exists() else None,
+    )
+    out.success(f"Generated {output_dir / 'SKILL.md'}")
+    if install:
+        out.success(f"Installed to ~/.claude/skills/{skill_name}/")