repowatch 0.4.0__py3-none-any.whl

repowatch/core.py

@@ -0,0 +1,399 @@
+"""Repo discovery and status. No UI code here — everything returns plain data."""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from urllib.parse import urlparse
+
+from .config import Config
+
+SKIP_DIRS = {
+    "node_modules", ".venv", "venv", "env", "__pycache__", ".tox", ".mypy_cache",
+    ".pytest_cache", "build", "dist", "target", ".idea", ".vscode", ".gradle",
+}
+
+# Never let git block on a prompt: no terminal prompts, no credential-manager pop-ups.
+_GIT_ENV_OVERRIDES = {
+    "GIT_TERMINAL_PROMPT": "0",
+    "GCM_INTERACTIVE": "never",
+    "LC_ALL": "C",
+}
+
+
+def git_env() -> dict[str, str]:
+    """Current environment plus the no-prompt overrides (read per call, not at import)."""
+    return {**os.environ, **_GIT_ENV_OVERRIDES}
+
+_NO_WINDOW = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+
+
+def git(path: Path | str, *args: str, timeout: float = 15) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["git", "-C", str(path), *args],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        env=git_env(),
+        timeout=timeout,
+        stdin=subprocess.DEVNULL,
+        creationflags=_NO_WINDOW,
+    )
+
+
+# --------------------------------------------------------------------------- data
+
+
+@dataclass
+class RemoteStatus:
+    name: str
+    label: str
+    url: str
+    host: str
+    ref: str | None = None          # e.g. "origin/main"
+    sha: str | None = None
+    ahead: int | None = None        # local commits not on remote  (→ needs push)
+    behind: int | None = None       # remote commits not in local  (→ needs pull)
+    error: str | None = None        # last fetch error, if any
+    mirror: bool = False            # read-only mirror of another remote (e.g. a Gitea pull mirror)
+
+    @property
+    def state(self) -> str:
+        if self.error:
+            return "unreachable"
+        if self.sha is None:
+            return "missing"
+        if self.ahead is None:
+            return "unknown"
+        if self.ahead == 0 and self.behind == 0:
+            return "synced"
+        if self.ahead and self.behind:
+            return "diverged"
+        return "ahead" if self.ahead else "behind"
+
+
+@dataclass
+class RepoStatus:
+    path: str
+    name: str
+    branch: str | None = None
+    detached: bool = False
+    head: str | None = None
+    upstream: str | None = None
+    staged: int = 0
+    unstaged: int = 0
+    untracked: int = 0
+    conflicts: int = 0
+    stashes: int = 0
+    last_fetch: float | None = None
+    remotes: list[RemoteStatus] = field(default_factory=list)
+    error: str | None = None
+
+    @property
+    def dirty(self) -> bool:
+        return bool(self.staged or self.unstaged or self.conflicts)
+
+    def remote(self, label: str) -> RemoteStatus | None:
+        return next((r for r in self.remotes if r.label == label), None)
+
+    def flags(self) -> list[str]:
+        if self.error:
+            return ["error"]
+        out: list[str] = []
+        if self.conflicts:
+            out.append("conflicts")
+        if self.dirty:
+            out.append("dirty")
+        if self.untracked:
+            out.append("untracked")
+        if self.stashes:
+            out.append("stash")
+        primary = [r for r in self.remotes if not r.mirror]
+        mirrors = [r for r in self.remotes if r.mirror]
+        states = {r.state for r in primary}
+        if "diverged" in states:
+            out.append("diverged")
+        if "ahead" in states:
+            out.append("push")
+        if "behind" in states:
+            out.append("pull")
+        tips = {r.sha for r in primary if r.sha}
+        if len(tips) > 1:
+            out.append("remotes differ")
+        # A mirror is "lagging" if it doesn't match what the primary remote(s) have.
+        if tips and any(m.sha not in tips and m.state != "unreachable" for m in mirrors):
+            out.append("mirror lag")
+        if "unreachable" in {r.state for r in self.remotes}:
+            out.append("unreachable")
+        if not self.remotes:
+            out.append("no remotes")
+        return out
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["flags"] = self.flags()
+        for rd, r in zip(d["remotes"], self.remotes, strict=True):
+            rd["state"] = r.state
+        return d
+
+
+# ----------------------------------------------------------------------- discovery
+
+
+def find_repos(root: Path | str, max_depth: int = 3) -> list[Path]:
+    root = Path(root).expanduser().resolve()
+    found: list[Path] = []
+
+    def walk(d: Path, depth: int) -> None:
+        if (d / ".git").exists():
+            found.append(d)
+            return  # don't descend into repos (submodules/vendored repos ignored)
+        if depth >= max_depth:
+            return
+        try:
+            entries = sorted(os.scandir(d), key=lambda e: e.name.lower())
+        except OSError:
+            return
+        for e in entries:
+            try:
+                is_dir = e.is_dir(follow_symlinks=False)
+            except OSError:
+                continue
+            if is_dir and e.name not in SKIP_DIRS and not e.name.startswith("."):
+                walk(Path(e.path), depth + 1)
+
+    walk(root, 0)
+    return found
+
+
+# ---------------------------------------------------------------------- remotes
+
+
+_SCP_LIKE = re.compile(r"^(?:[\w.+-]+@)?(?P<host>[\w.-]+):(?!//)(?P<path>.+)$")
+
+
+def url_host(url: str) -> str:
+    if "://" not in url:
+        m = _SCP_LIKE.match(url)
+        # Guard against Windows drive letters (C:/...) being read as hosts.
+        if m and len(m.group("host")) > 1:
+            return m.group("host").lower()
+        return ""
+    return (urlparse(url).hostname or "").lower()
+
+
+def url_owner_repo(url: str) -> tuple[str, str] | None:
+    if "://" in url:
+        path = urlparse(url).path
+    else:
+        m = _SCP_LIKE.match(url)
+        path = m.group("path") if m else url
+    parts = [p for p in re.split(r"[\\/]", path) if p]
+    if len(parts) < 2:
+        return None
+    repo = parts[-1].removesuffix(".git")
+    return parts[-2], repo
+
+
+def label_for(remote_name: str, url: str, hosts: dict[str, str]) -> str:
+    host = url_host(url)
+    if host:
+        if host in hosts:
+            return hosts[host]
+        for key, lab in hosts.items():
+            if key in host:
+                return lab
+        if "gitea" in host:
+            return "gitea"
+        if "github" in host:
+            return "github"
+    return remote_name
+
+
+def list_remotes(path: Path | str) -> dict[str, str]:
+    """Remote name -> URL as configured (before any url.insteadOf rewriting)."""
+    out: dict[str, str] = {}
+    cp = git(path, "config", "--local", "--get-regexp", r"^remote\..*\.url$")
+    for line in cp.stdout.splitlines():
+        key, _, url = line.partition(" ")
+        name = key[len("remote."):-len(".url")]
+        out.setdefault(name, url.strip())
+    return out
+
+
+# ----------------------------------------------------------------------- status
+
+
+def _parse_status(text: str, st: RepoStatus) -> None:
+    for line in text.splitlines():
+        if line.startswith("# branch.oid "):
+            oid = line.split(" ", 2)[2]
+            st.head = None if oid == "(initial)" else oid
+        elif line.startswith("# branch.head "):
+            head = line.split(" ", 2)[2]
+            st.detached = head == "(detached)"
+            st.branch = None if st.detached else head
+        elif line.startswith("# branch.upstream "):
+            st.upstream = line.split(" ", 2)[2]
+        elif line.startswith(("1 ", "2 ")):
+            xy = line[2:4]
+            if xy[0] != ".":
+                st.staged += 1
+            if xy[1] != ".":
+                st.unstaged += 1
+        elif line.startswith("u "):
+            st.conflicts += 1
+        elif line.startswith("? "):
+            st.untracked += 1
+
+
+def repo_status(
+    path: Path | str,
+    root: Path | str,
+    cfg: Config,
+    fetch_errors: dict[str, str] | None = None,
+) -> RepoStatus:
+    path = Path(path)
+    try:
+        name = path.relative_to(Path(root).expanduser().resolve()).as_posix() or path.name
+    except ValueError:
+        name = path.name
+    st = RepoStatus(path=str(path), name=name or path.name)
+    fetch_errors = fetch_errors or {}
+
+    try:
+        cp = git(path, "status", "--porcelain=v2", "--branch")
+        if cp.returncode != 0:
+            st.error = (cp.stderr.strip().splitlines() or ["git status failed"])[-1]
+            return st
+        _parse_status(cp.stdout, st)
+
+        cp = git(path, "stash", "list", "--format=%h")
+        st.stashes = len([l for l in cp.stdout.splitlines() if l.strip()])
+
+        gd = git(path, "rev-parse", "--git-common-dir").stdout.strip() or ".git"
+        fh = (path / gd) / "FETCH_HEAD"  # absolute gd overrides path on join
+        if fh.exists():
+            st.last_fetch = fh.stat().st_mtime
+
+        remotes = list_remotes(path)
+        cp = git(path, "for-each-ref", "--format=%(refname:strip=2)%09%(objectname)", "refs/remotes")
+        refs = dict(l.split("\t", 1) for l in cp.stdout.splitlines() if "\t" in l)
+
+        used_labels: set[str] = set()
+        for rname, url in remotes.items():
+            label = label_for(rname, url, cfg.hosts)
+            if label in used_labels:
+                label = f"{label}:{rname}"
+            used_labels.add(label)
+            rs = RemoteStatus(name=rname, label=label, url=url, host=url_host(url),
+                              error=fetch_errors.get(rname),
+                              mirror=label.split(":")[0] in cfg.mirror_labels)
+
+            if st.branch:
+                candidates = [f"{rname}/{st.branch}"]
+            else:  # detached: compare to the remote's default branch
+                candidates = [f"{rname}/HEAD", f"{rname}/main", f"{rname}/master"]
+            for cand in candidates:
+                if cand in refs:
+                    rs.ref, rs.sha = cand, refs[cand]
+                    break
+
+            if rs.sha and st.head:
+                if rs.sha == st.head:
+                    rs.ahead = rs.behind = 0
+                else:
+                    cp = git(path, "rev-list", "--left-right", "--count", f"HEAD...{rs.sha}")
+                    if cp.returncode == 0 and cp.stdout.strip():
+                        a, b = cp.stdout.split()
+                        rs.ahead, rs.behind = int(a), int(b)
+            st.remotes.append(rs)
+    except subprocess.TimeoutExpired:
+        st.error = "git timed out"
+    except Exception as exc:  # keep one broken repo from killing the whole scan
+        st.error = f"{type(exc).__name__}: {exc}"
+    return st
+
+
+# ------------------------------------------------------------------------ fetch
+
+
+def _ssh_override(path: Path | str) -> list[str]:
+    """Make ssh fail fast instead of prompting, unless the user has their own sshCommand."""
+    cp = git(path, "config", "--get", "core.sshCommand")
+    if cp.returncode == 0 and cp.stdout.strip():
+        return []
+    return ["-c", "core.sshCommand=ssh -o BatchMode=yes -o ConnectTimeout=8"]
+
+
+def fetch_repo(path: Path | str, timeout: float = 25, remotes: list[str] | None = None) -> dict[str, str]:
+    """Fetch each remote separately so one unreachable remote doesn't block the others.
+    Returns {remote_name: error} for the ones that failed."""
+    errors: dict[str, str] = {}
+    names = remotes or list(list_remotes(path))
+    ssh = _ssh_override(path)
+    for rname in names:
+        try:
+            cp = git(path, *ssh, "fetch", "--prune", "--quiet", rname, timeout=timeout)
+            if cp.returncode != 0:
+                lines = [l.strip() for l in cp.stderr.splitlines() if l.strip()]
+                key = next((l for l in lines if l.startswith(("fatal:", "error:"))), None)
+                errors[rname] = key or (lines[0] if lines else f"fetch failed ({cp.returncode})")
+        except subprocess.TimeoutExpired:
+            errors[rname] = f"timed out after {timeout:.0f}s"
+    return errors
+
+
+def add_remote(path: Path | str, name: str, url: str) -> str | None:
+    cp = git(path, "remote", "add", name, url)
+    if cp.returncode != 0:
+        return (cp.stderr.strip().splitlines() or ["git remote add failed"])[-1]
+    return None
+
+
+# ------------------------------------------------------------------------- bulk
+
+
+def scan(
+    root: Path | str,
+    cfg: Config,
+    do_fetch: bool = False,
+    workers: int = 8,
+    fetch_errors: dict[str, dict[str, str]] | None = None,
+) -> list[RepoStatus]:
+    repos = find_repos(root, cfg.depth)
+    fetch_errors = fetch_errors if fetch_errors is not None else {}
+
+    def one(p: Path) -> RepoStatus:
+        if do_fetch:
+            fetch_errors[str(p)] = fetch_repo(p, cfg.fetch_timeout)
+        return repo_status(p, root, cfg, fetch_errors.get(str(p)))
+
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        return list(pool.map(one, repos))
+
+
+def all_labels(statuses: list[RepoStatus], order: list[str]) -> list[str]:
+    seen = {r.label for s in statuses for r in s.remotes}
+    first = [l for l in order if l in seen]
+    return first + sorted(seen - set(first))
+
+
+def ago(ts: float | None) -> str:
+    if not ts:
+        return "never"
+    d = time.time() - ts
+    if d < 90:
+        return "just now"
+    if d < 3600:
+        return f"{d / 60:.0f}m ago"
+    if d < 86400 * 2:
+        return f"{d / 3600:.0f}h ago"
+    return f"{d / 86400:.0f}d ago"

repowatch/prune.py

@@ -0,0 +1,209 @@
+"""Find and delete stale branches on the primary remote (GitHub).
+
+A branch is deletable when its work is already in the default branch:
+  merged         its tip is an ancestor of main (merge commit / fast-forward / rebase)
+  squash-merged  its combined change already exists in main as one squashed commit
+
+Unmerged branches are only reported, unless --include-unmerged DAYS is given, and then
+only those older than DAYS with no open pull request (needs the GitHub CLI `gh`).
+Never touched: the default branch, anything matching prune_keep, branches younger than
+prune_min_age_days, and anything checked out locally.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import time
+from dataclasses import dataclass, field
+from fnmatch import fnmatchcase
+from pathlib import Path
+
+from . import core
+from .config import Config
+
+
+@dataclass
+class Branch:
+    name: str
+    sha: str
+    age_days: int
+    kind: str                  # merged | squash-merged | unmerged
+    ahead: int = 0             # commits not in default (unmerged only)
+    delete: bool = False
+    reason: str = ""           # why kept
+    deleted: bool | None = None
+
+
+@dataclass
+class PruneResult:
+    path: str
+    name: str
+    remote: str = ""
+    default: str = ""
+    branches: list[Branch] = field(default_factory=list)
+    skipped: str | None = None
+    note: str | None = None
+    error: str | None = None
+
+    @property
+    def to_delete(self) -> list[Branch]:
+        return [b for b in self.branches if b.delete]
+
+
+_ID = ["-c", "user.name=repowatch", "-c", "user.email=repowatch@localhost"]
+
+
+def _squash_merged(path: str, sha: str, default_ref: str) -> bool:
+    """True if the branch's net change is already in default (the git-delete-squashed trick)."""
+    mb = core.git(path, "merge-base", default_ref, sha).stdout.strip()
+    if not mb:
+        return False
+    tree = core.git(path, "rev-parse", f"{sha}^{{tree}}").stdout.strip()
+    tmp = core.git(path, *_ID, "commit-tree", tree, "-p", mb, "-m", "repowatch-squash-probe").stdout.strip()
+    if not tmp:
+        return False
+    out = core.git(path, "cherry", default_ref, tmp).stdout.strip()
+    return out.startswith("-")
+
+
+def _open_pr_heads(url: str) -> set[str] | None:
+    """Head branch names of open PRs, via `gh`. None if gh is missing or fails."""
+    if not shutil.which("gh") or "github.com" not in url:
+        return None
+    owner_repo = core.url_owner_repo(url)
+    if not owner_repo:
+        return None
+    import subprocess
+
+    try:
+        cp = subprocess.run(
+            ["gh", "pr", "list", "-R", "/".join(owner_repo), "--state", "open",
+             "--json", "headRefName", "--limit", "500"],
+            capture_output=True, text=True, encoding="utf-8", timeout=30,
+            creationflags=core._NO_WINDOW,
+        )
+        if cp.returncode != 0:
+            return None
+        return {pr["headRefName"] for pr in json.loads(cp.stdout or "[]")}
+    except Exception:
+        return None
+
+
+def plan_and_run(path: str, root: str, cfg: Config, apply: bool = False,
+                 include_unmerged_days: int | None = None, min_age_days: int | None = None) -> PruneResult:
+    status = core.repo_status(path, root, cfg)
+    res = PruneResult(path=str(path), name=status.name)
+    if status.error:
+        res.skipped = status.error
+        return res
+    primary = next((r for r in status.remotes if r.label.split(":")[0] in cfg.primary_labels), None)
+    if primary is None:
+        res.skipped = "no primary remote"
+        return res
+    res.remote = primary.label
+
+    errs = core.fetch_repo(path, cfg.fetch_timeout, remotes=[primary.name])
+    if errs:
+        res.skipped = f"{primary.label} unreachable: {errs[primary.name]}"
+        return res
+
+    # default branch
+    cp = core.git(path, "symbolic-ref", "--short", f"refs/remotes/{primary.name}/HEAD")
+    if cp.returncode != 0:
+        core.git(path, "remote", "set-head", primary.name, "--auto", timeout=cfg.fetch_timeout)
+        cp = core.git(path, "symbolic-ref", "--short", f"refs/remotes/{primary.name}/HEAD")
+    default_ref = cp.stdout.strip()
+    if not default_ref:
+        for cand in ("main", "master"):
+            if core.git(path, "rev-parse", "--verify", "-q", f"{primary.name}/{cand}").returncode == 0:
+                default_ref = f"{primary.name}/{cand}"
+                break
+    if not default_ref:
+        res.skipped = "can't tell the default branch"
+        return res
+    default = default_ref.split("/", 1)[1]
+    res.default = default
+
+    min_age = cfg.prune_min_age_days if min_age_days is None else min_age_days
+    keep = set(cfg.prune_keep) | {default}
+    local_heads = set(core.git(path, "for-each-ref", "--format=%(refname:short)", "refs/heads").stdout.split())
+
+    cp = core.git(path, "for-each-ref", "--format=%(refname:strip=3)%09%(objectname)%09%(committerdate:unix)",
+                  f"refs/remotes/{primary.name}")
+    now = time.time()
+    open_prs: set[str] | None = None
+    if include_unmerged_days is not None:
+        open_prs = _open_pr_heads(primary.url)
+        if open_prs is None:
+            res.note = "unmerged branches not deleted: open-PR check needs the GitHub CLI (gh) signed in"
+
+    for line in cp.stdout.splitlines():
+        parts = line.split("\t")
+        if len(parts) != 3 or parts[0] in ("HEAD", default):
+            continue
+        name, sha, ts = parts
+        age = int((now - int(ts)) / 86400) if ts.isdigit() else 0
+        if core.git(path, "merge-base", "--is-ancestor", sha, default_ref).returncode == 0:
+            kind = "merged"
+        elif _squash_merged(path, sha, default_ref):
+            kind = "squash-merged"
+        else:
+            kind = "unmerged"
+        b = Branch(name=name, sha=sha, age_days=age, kind=kind)
+        if kind == "unmerged":
+            b.ahead = int(core.git(path, "rev-list", "--count", f"{default_ref}..{sha}").stdout.strip() or 0)
+
+        if any(fnmatchcase(name, pat) for pat in keep):
+            b.reason = "kept by prune_keep"
+        elif name in local_heads and name == status.branch:
+            b.reason = "checked out locally"
+        elif age < min_age:
+            b.reason = f"younger than {min_age}d"
+        elif kind != "unmerged":
+            b.delete = True
+        elif include_unmerged_days is None:
+            b.reason = "unmerged"
+        elif open_prs is None:
+            b.reason = "unmerged (no PR check)"
+        elif name in open_prs:
+            b.reason = "open PR"
+        elif age < include_unmerged_days:
+            b.reason = f"unmerged, younger than {include_unmerged_days}d"
+        else:
+            b.delete = True
+        res.branches.append(b)
+
+    order = {"merged": 0, "squash-merged": 1, "unmerged": 2}
+    res.branches.sort(key=lambda b: (not b.delete, order[b.kind], b.name))
+
+    if apply and res.to_delete:
+        names = [b.name for b in res.to_delete]
+        ssh = core._ssh_override(path)
+        for i in range(0, len(names), 50):  # batches keep the command line short
+            core.git(path, *ssh, "push", primary.name, "--delete", *names[i:i + 50],
+                     timeout=cfg.fetch_timeout * 4)
+        # Verify against the remote rather than parsing push output.
+        cp = core.git(path, *ssh, "ls-remote", "--heads", primary.name, timeout=cfg.fetch_timeout)
+        remaining = {l.split("refs/heads/", 1)[1] for l in cp.stdout.splitlines() if "refs/heads/" in l}
+        if cp.returncode != 0:
+            res.error = "couldn't verify deletions: " + (cp.stderr.strip().splitlines() or ["ls-remote failed"])[-1]
+        for b in res.to_delete:
+            b.deleted = None if cp.returncode != 0 else (b.name not in remaining)
+        core.git(path, "fetch", "--prune", "--quiet", primary.name, timeout=cfg.fetch_timeout)
+    return res
+
+
+def prune_all(root: str, cfg: Config, apply: bool = False, names: list[str] | None = None,
+              include_unmerged_days: int | None = None, min_age_days: int | None = None,
+              workers: int = 4) -> list[PruneResult]:
+    from concurrent.futures import ThreadPoolExecutor
+
+    root = str(Path(root).expanduser().resolve())
+    repos = [str(p) for p in core.find_repos(root, cfg.depth)]
+    if names:
+        wanted = {n.lower() for n in names}
+        repos = [p for p in repos if Path(p).name.lower() in wanted
+                 or Path(p).relative_to(root).as_posix().lower() in wanted]
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        return list(pool.map(lambda p: plan_and_run(p, root, cfg, apply, include_unmerged_days, min_age_days), repos))