polygit 0.3.0__tar.gz → 0.3.2__tar.gz

{polygit-0.3.0 → polygit-0.3.2}/.gitlab-ci.yml

@@ -1,3 +1,8 @@
+include:
+  - project: "gary.schaetz/private/pipelines"
+    ref: main
+    file: 'templates/rules/rules.yml'
+
 stages:
   - test
   - build
@@ -12,6 +17,14 @@ test:
   tags:
     - docker
     - kubernetes
+  # Explicit rules instead of relying on GitLab's implicit default (only: [branches, tags]):
+  # that default happens to exclude merge_request_event already, but making it explicit here
+  # matches the pattern every other repo running on these self-hosted runners uses, rather
+  # than depending on undocumented default behavior for a job that runs arbitrary repo code.
+  rules:
+    - !reference [.job_rules, standard-rule]
+    - !reference [.job_rules, manual-rule]
+    - !reference [.job_rules, schedule-rule]
   script:
     - uv sync
     - uv run pytest

polygit-0.3.2/AGENTS.md

@@ -0,0 +1,15 @@
+# Repo context for AI agents
+
+Published Python package (`pip install polygit`, installed via `uv tool install` per the
+user's `setup-new-machine.sh` bootstrap docs — see project memory) providing the `pgit` CLI:
+manages multiple git repos (across GitHub/GitLab, multiple orgs/namespaces) from a single
+`.pgit` config file. `.pgit` is discovered by walking up from the current directory, so
+`pgit` commands work from anywhere inside the repos root — this is in fact what manages the
+very `~/development/gitlab` tree these AGENTS.md files live in.
+
+Standard `src`-layout Python package (`pyproject.toml`, `uv.lock` — uses `uv`, not
+pip/poetry, for dev dependency management). `.gitlab-ci.yml` presumably builds/publishes on
+tag, mirroring `gitlab-ci-generator`'s pattern.
+
+Replaced an older `sync.sh` script (see recent commit history) — if you find references to
+`sync.sh` elsewhere in the user's dotfiles/bootstrap scripts, they're stale.

polygit-0.3.2/CLAUDE.md

@@ -0,0 +1,3 @@
+# Claude Code context
+
+See [AGENTS.md](AGENTS.md) for repo overview.

{polygit-0.3.0 → polygit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polygit
-Version: 0.3.0
+Version: 0.3.2
 Summary: Manage multiple git repos from a single .pgit config file.
 Project-URL: Repository, https://gitlab.com/gary.schaetz/public/polygit
 Author-email: Gary Schaetz <gary@schaetzkc.com>

{polygit-0.3.0 → polygit-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "polygit"
-version = "0.3.0"
+version = "0.3.2"
 description = "Manage multiple git repos from a single .pgit config file."
 readme = "README.md"
 license = { file = "LICENSE.txt" }

{polygit-0.3.0 → polygit-0.3.2}/src/polygit/repo.py

@@ -1,6 +1,8 @@
+import shutil
 import subprocess
 import sys
 import threading
+import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from pathlib import Path
@@ -9,6 +11,39 @@ from .config import HOSTS
 _print_lock = threading.Lock()
 MAX_WORKERS = 8
 
+# Errors seen when the SSH server drops a connection under concurrent load
+# rather than a real failure — safe to retry.
+_TRANSIENT_ERR_MARKERS = (
+    "kex_exchange_identification",
+    "Connection reset by peer",
+    "Connection timed out",
+    "Could not read from remote repository",
+    "early EOF",
+    "The remote end hung up unexpectedly",
+)
+
+
+def _is_transient(stderr):
+    return any(marker in stderr for marker in _TRANSIENT_ERR_MARKERS)
+
+
+def _run_git(args, retries=2, delay=1.5, cleanup=None):
+    """Run a git subprocess, retrying on transient SSH/network errors.
+
+    `cleanup`, if given, runs before each retry (e.g. to remove a partial
+    clone directory left behind by the failed attempt).
+    """
+    for attempt in range(retries + 1):
+        result = subprocess.run(args, capture_output=True, text=True)
+        if result.returncode == 0 or not _is_transient(result.stderr):
+            return result
+        if attempt < retries:
+            if cleanup:
+                cleanup()
+            time.sleep(delay * (attempt + 1))
+    return result
+
+
 _USE_COLOR = sys.stdout.isatty()
 
 _G  = "\033[32m" if _USE_COLOR else ""   # green
@@ -18,10 +53,11 @@ _Y  = "\033[33m" if _USE_COLOR else ""   # yellow
 _DIM = "\033[2m" if _USE_COLOR else ""   # dim
 _RST = "\033[0m" if _USE_COLOR else ""   # reset
 
-OK  = f"{_G}✓{_RST}"
-UPD = f"{_C}↓{_RST}"
-ERR = f"{_R}✗{_RST}"
-NEW = f"{_C}+{_RST}"
+OK   = f"{_G}✓{_RST}"
+UPD  = f"{_G}↓{_RST}"
+ERR  = f"{_R}✗{_RST}"
+WARN = f"{_Y}⚠{_RST}"
+NEW  = f"{_C}+{_RST}"
 
 
 def _emit(lines):
@@ -71,7 +107,7 @@ def _commit_and_push(d, label, msg):
     lines = [f"  Committing {label}..."]
     subprocess.run(["git", "-C", str(d), "add", "-A"], capture_output=True)
     subprocess.run(["git", "-C", str(d), "commit", "-m", msg], capture_output=True)
-    result = subprocess.run(["git", "-C", str(d), "push"], capture_output=True, text=True)
+    result = _run_git(["git", "-C", str(d), "push"])
     if result.returncode != 0:
         lines.append(f"{ERR} {label}: push failed — {result.stderr.strip().splitlines()[0]}")
     else:
@@ -83,19 +119,16 @@ def _sync_one(platform, local_path, remote_path, d):
     url = f"{HOSTS[platform]}:{remote_path}.git"
     label = f"{platform}/{local_path}"
     if (d / ".git").exists():
-        result = subprocess.run(
-            ["git", "-C", str(d), "fetch", "--all", "-q"],
-            capture_output=True, text=True
-        )
+        result = _run_git(["git", "-C", str(d), "fetch", "--all", "-q"])
         if result.returncode != 0:
             lines = [f"{ERR} {label}: {result.stderr.strip().splitlines()[0]}"]
         else:
             lines = [f"{OK} {_DIM}{label}{_RST}"]
     else:
         d.parent.mkdir(parents=True, exist_ok=True)
-        result = subprocess.run(
+        result = _run_git(
             ["git", "clone", url, str(d)],
-            capture_output=True, text=True
+            cleanup=lambda: shutil.rmtree(d, ignore_errors=True),
         )
         if result.returncode != 0:
             lines = [f"{ERR} {label}: {result.stderr.strip().splitlines()[0]}"]
@@ -111,17 +144,14 @@ def _pull_one(platform, local_path, d):
     if is_dirty(d):
         subprocess.run(["git", "-C", str(d), "stash"], capture_output=True)
         stashed = True
-    result = subprocess.run(
-        ["git", "-C", str(d), "pull", "--rebase"],
-        capture_output=True, text=True
-    )
+    result = _run_git(["git", "-C", str(d), "pull", "--rebase"])
     if result.returncode != 0:
         err = result.stderr.strip()
         if "no tracking information" in err or "no upstream" in err.lower():
-            lines.append(f"{ERR} {label}: no upstream branch set")
+            lines.append(f"{WARN} {label}: no upstream branch set")
         else:
             lines.append(f"{ERR} {label}: {err.splitlines()[0]}")
-    elif result.stdout.strip() and result.stdout.strip() != "Already up to date.":
+    elif result.stdout.strip() and "up to date" not in result.stdout.lower():
         lines.append(f"{UPD} {label}:")
         for ln in result.stdout.strip().splitlines():
             lines.append(f"   {ln}")

{polygit-0.3.0 → polygit-0.3.2}/uv.lock

@@ -90,7 +90,7 @@ wheels = [
 
 [[package]]
 name = "polygit"
-version = "0.1.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },