polygit 0.4.0__tar.gz → 0.6.0__tar.gz

{polygit-0.4.0 → polygit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: polygit
-Version: 0.4.0
+Version: 0.6.0
 Summary: Manage multiple git repos from a single .pgit config file.
 Project-URL: Repository, https://github.com/gschaetz/polygit
 Author-email: Gary Schaetz <gary@schaetzkc.com>
@@ -49,6 +49,17 @@ pgit push      # interactively commit and push dirty repos
 pgit repos     # discover drift between .pgit and the filesystem
 ```
 
+`status`, `pull` and `push` accept `--only <platform>` to operate on a single platform
+(e.g. `github`) instead of all of them:
+
+```bash
+pgit status --only gitlab
+pgit pull   --only github --dry-run
+pgit push   --only gitlab --all
+```
+
+Passing an unknown platform prints an error to stderr and exits 1.
+
 ## Configuration
 
 Create a `.pgit` file in the root directory that contains your repos:
@@ -96,6 +107,20 @@ pgit push --dry-run      # list dirty repos that would be committed and pushed
 
 `pull --dry-run` compares against the last fetched state of each upstream, so run `pgit sync` first for current numbers.
 
+## status --json
+
+```bash
+pgit status --json   # machine-readable list of dirty repos
+```
+
+Prints a single JSON array on stdout and nothing else:
+
+```json
+[{"platform": "github", "path": "gschaetz/mousehat", "changed_files": 2}]
+```
+
+`changed_files` is the number of entries in `git status --short`. Clean repos are omitted, so the array is empty when there is nothing to commit.
+
 ## repos — drift detection
 
 `pgit repos` compares what's actually on disk against your `.pgit` config and reports:

{polygit-0.4.0 → polygit-0.6.0}/README.md

@@ -16,6 +16,17 @@ pgit push      # interactively commit and push dirty repos
 pgit repos     # discover drift between .pgit and the filesystem
 ```
 
+`status`, `pull` and `push` accept `--only <platform>` to operate on a single platform
+(e.g. `github`) instead of all of them:
+
+```bash
+pgit status --only gitlab
+pgit pull   --only github --dry-run
+pgit push   --only gitlab --all
+```
+
+Passing an unknown platform prints an error to stderr and exits 1.
+
 ## Configuration
 
 Create a `.pgit` file in the root directory that contains your repos:
@@ -63,6 +74,20 @@ pgit push --dry-run      # list dirty repos that would be committed and pushed
 
 `pull --dry-run` compares against the last fetched state of each upstream, so run `pgit sync` first for current numbers.
 
+## status --json
+
+```bash
+pgit status --json   # machine-readable list of dirty repos
+```
+
+Prints a single JSON array on stdout and nothing else:
+
+```json
+[{"platform": "github", "path": "gschaetz/mousehat", "changed_files": 2}]
+```
+
+`changed_files` is the number of entries in `git status --short`. Clean repos are omitted, so the array is empty when there is nothing to commit.
+
 ## repos — drift detection
 
 `pgit repos` compares what's actually on disk against your `.pgit` config and reports:

{polygit-0.4.0 → polygit-0.6.0}/pyproject.toml

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

{polygit-0.4.0 → polygit-0.6.0}/src/polygit/cli.py

@@ -1,6 +1,6 @@
 import sys
 import argparse
-from .config import find_config, load_config
+from .config import find_config, load_config, HOSTS
 from .repo import cmd_sync, cmd_status, cmd_pull, cmd_push
 from .repos import cmd_repos
 
@@ -13,10 +13,14 @@ def main():
     sub = parser.add_subparsers(dest="command", metavar="command")
 
     sub.add_parser("sync",   help="Clone missing repos and fetch all")
-    sub.add_parser("status", help="Show repos with uncommitted changes")
+    status_p = sub.add_parser("status", help="Show repos with uncommitted changes")
+    status_p.add_argument("--json", action="store_true",
+                          help="Print dirty repos as a JSON list")
+    status_p.add_argument("--only", dest="only_platform", help="Limit to a single platform (e.g. github)")
     pull_p = sub.add_parser("pull",   help="Pull all repos, auto-stashing local changes")
     pull_p.add_argument("--dry-run", action="store_true",
                         help="Show ahead/behind vs. last-fetched upstream; changes nothing")
+    pull_p.add_argument("--only", dest="only_platform", help="Limit to a single platform (e.g. github)")
 
     push_p = sub.add_parser("push", help="Commit and push dirty repos")
     mode_g = push_p.add_mutually_exclusive_group()
@@ -29,6 +33,7 @@ def main():
     push_p.set_defaults(push_mode="interactive")
     push_p.add_argument("--dry-run", action="store_true",
                         help="Show the commit/push plan without committing or pushing")
+    push_p.add_argument("--only", dest="only_platform", help="Limit to a single platform (e.g. github)")
 
     sub.add_parser("repos", help="Discover drift between .pgit and the filesystem")
 
@@ -47,11 +52,17 @@ def main():
     base   = config_path.parent
     config = load_config(config_path)
 
+    only_platform = getattr(args, "only_platform", None)
+    if only_platform is not None and only_platform not in HOSTS:
+        print(f"Error: unknown platform '{only_platform}'. "
+              f"Available: {', '.join(sorted(HOSTS))}", file=sys.stderr)
+        sys.exit(1)
+
     commands = {
         "sync":   lambda: cmd_sync(config, base),
-        "status": lambda: cmd_status(config, base),
-        "pull":   lambda: cmd_pull(config, base, dry_run=args.dry_run),
-        "push":   lambda: cmd_push(config, base, mode=args.push_mode, dry_run=args.dry_run),
+        "status": lambda: cmd_status(config, base, json_output=args.json, only=only_platform),
+        "pull":   lambda: cmd_pull(config, base, dry_run=args.dry_run, only=only_platform),
+        "push":   lambda: cmd_push(config, base, mode=args.push_mode, dry_run=args.dry_run, only=only_platform),
         "repos":  lambda: cmd_repos(config, base, config_path),
     }
     commands[args.command]()

{polygit-0.4.0 → polygit-0.6.0}/src/polygit/repo.py

@@ -1,3 +1,4 @@
+import json
 import shutil
 import subprocess
 import sys
@@ -88,9 +89,15 @@ def each_repo(config, base):
                 yield platform, local_path, remote_path, base / platform / local_path
 
 
-def each_existing_repo(config, base):
-    """Yield only repos that are already cloned locally."""
+def each_existing_repo(config, base, only=None):
+    """Yield only repos that are already cloned locally.
+
+    If *only* is set, only repos under that platform are yielded. The helper
+    is used by :func:`cmd_status`, :func:`cmd_pull` and :func:`cmd_push`.
+    """
     for platform, local_path, remote_path, d in each_repo(config, base):
+        if only is not None and platform != only:
+            continue
         if (d / ".git").exists():
             yield platform, local_path, remote_path, d
 
@@ -194,7 +201,7 @@ def cmd_sync(config, base):
             f.result()
 
 
-def cmd_status(config, base):
+def cmd_status(config, base, json_output=False, only=None):
     results = []
 
     def _check(platform, local_path, d):
@@ -204,12 +211,21 @@ def cmd_status(config, base):
         )
         return platform, local_path, result.stdout.strip()
 
-    repos = list(each_existing_repo(config, base))
+    repos = list(each_existing_repo(config, base, only=only))
     with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool:
         futures = {pool.submit(_check, p, lp, d): (p, lp) for p, lp, _, d in repos}
         for f in as_completed(futures):
             results.append(f.result())
 
+    if json_output:
+        entries = [
+            {"platform": platform, "path": local_path, "changed_files": len(output.splitlines())}
+            for platform, local_path, output in sorted(results)
+            if output
+        ]
+        print(json.dumps(entries))
+        return
+
     found_dirty = False
     for platform, local_path, output in sorted(results):
         if output:
@@ -221,18 +237,18 @@ def cmd_status(config, base):
         print(f"{OK} All repos are clean.")
 
 
-def cmd_pull(config, base, dry_run=False):
-    repos = list(each_existing_repo(config, base))
+def cmd_pull(config, base, dry_run=False, only=None):
+    repos = list(each_existing_repo(config, base, only=only))
     with ThreadPoolExecutor(max_workers=MAX_WORKERS) as pool:
         futures = [pool.submit(_pull_one, p, lp, d, dry_run) for p, lp, _, d in repos]
         for f in as_completed(futures):
             f.result()
 
 
-def cmd_push(config, base, mode="interactive", dry_run=False):
+def cmd_push(config, base, mode="interactive", dry_run=False, only=None):
     dirty = [
         (platform, local_path, d)
-        for platform, local_path, _, d in each_existing_repo(config, base)
+        for platform, local_path, _, d in each_existing_repo(config, base, only=only)
         if is_dirty(d)
     ]
 

{polygit-0.4.0 → polygit-0.6.0}/tests/test_polygit.py

@@ -1,10 +1,11 @@
+import json
 import subprocess
 import tempfile
 import pytest
 from pathlib import Path
 from polygit.config import find_config, load_config, write_config
 from polygit.repos import parse_remote_url, del_nested, _add_to_config
-from polygit.repo import walk, _pull_one, cmd_push
+from polygit.repo import walk, _pull_one, cmd_push, cmd_status, cmd_pull
 
 
 # ── parse_remote_url ──────────────────────────────────────────────────────────
@@ -195,3 +196,142 @@ def test_push_dry_run_lists_dirty_without_committing(capsys, tmp_path):
     log = subprocess.run(["git", "-C", str(d), "log", "--oneline"],
                          capture_output=True, text=True).stdout
     assert len(log.splitlines()) == 1
+
+
+# ── status --json ────────────────────────────────────────────────────────────
+
+def test_status_json_lists_dirty_repos(capsys, tmp_path):
+    d = _make_clone(tmp_path)
+    (d / "init").write_text("edited")
+    (d / "a.txt").write_text("a")
+    (d / "b.txt").write_text("b")
+
+    cmd_status({"github": {"r": None}}, tmp_path, json_output=True)
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload == [{"platform": "github", "path": "r", "changed_files": 3}]
+
+
+def test_status_json_empty_when_clean(capsys, tmp_path):
+    _make_clone(tmp_path)
+    cmd_status({"github": {"r": None}}, tmp_path, json_output=True)
+    assert json.loads(capsys.readouterr().out) == []
+
+
+def test_status_json_omits_clean_repos(capsys, tmp_path):
+    _make_clone(tmp_path)
+    dirty = tmp_path / "github" / "other"
+    subprocess.run(["git", "clone", "-q", str(tmp_path / "origin.git"), str(dirty)],
+                   check=True, capture_output=True)
+    (dirty / "x.txt").write_text("x")
+
+    cmd_status({"github": {"r": None, "other": None}}, tmp_path, json_output=True)
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload == [{"platform": "github", "path": "other", "changed_files": 1}]
+
+
+def test_status_default_output_unchanged(capsys, tmp_path):
+    d = _make_clone(tmp_path)
+    (d / "dirty.txt").write_text("x")
+
+    cmd_status({"github": {"r": None}}, tmp_path)
+    out = capsys.readouterr().out
+
+    assert "github/r" in out
+    assert "dirty.txt" in out
+    assert out.strip()[0] != "["
+    with pytest.raises(ValueError):
+        json.loads(out)
+
+
+def test_status_default_clean_message(capsys, tmp_path):
+    _make_clone(tmp_path)
+    cmd_status({"github": {"r": None}}, tmp_path)
+    assert "All repos are clean." in capsys.readouterr().out
+
+
+# ── --only platform filter ───────────────────────────────────────────────────
+
+def _gitlab_clone(tmp_path, name="gl", commit=True):
+    d = tmp_path / "gitlab" / name
+    d.parent.mkdir()
+    subprocess.run(["git", "clone", "-q", str(tmp_path / "origin.git"), str(d)],
+                   check=True, capture_output=True)
+    if commit:
+        _commit(d, "seed")
+        _git(d, "push", "-q", "origin", "HEAD:main")
+    return d
+
+
+def test_status_only_limits_to_platform(capsys, tmp_path):
+    github = _make_clone(tmp_path)
+    (github / "x.txt").write_text("x")
+    _gitlab_clone(tmp_path)
+    (tmp_path / "gitlab" / "gl" / "y.txt").write_text("y")
+
+    cmd_status({"github": {"r": None}, "gitlab": {"gl": None}}, tmp_path, only="github")
+
+    out = capsys.readouterr().out
+    assert "github/r" in out
+    assert "gitlab/gl" not in out
+
+
+def test_status_only_json(capsys, tmp_path):
+    github = _make_clone(tmp_path)
+    (github / "x.txt").write_text("x")
+    _gitlab_clone(tmp_path)
+    (tmp_path / "gitlab" / "gl" / "y.txt").write_text("y")
+
+    cmd_status({"github": {"r": None}, "gitlab": {"gl": None}}, tmp_path,
+               json_output=True, only="github")
+
+    assert json.loads(capsys.readouterr().out) == [
+        {"platform": "github", "path": "r", "changed_files": 1}
+    ]
+
+
+def test_pull_only_limits_to_platform(capsys, tmp_path):
+    _make_clone(tmp_path, ahead=2)
+    _gitlab_clone(tmp_path)
+    _commit(tmp_path / "gitlab" / "gl", "ahead")
+    _git(tmp_path / "gitlab" / "gl", "push", "-q", "origin", "HEAD:main")
+
+    cmd_pull({"github": {"r": None}, "gitlab": {"gl": None}}, tmp_path,
+             dry_run=True, only="github")
+
+    out = capsys.readouterr().out
+    assert "github/r" in out
+    assert "gitlab/gl" not in out
+
+
+def test_push_only_limits_to_platform(capsys, tmp_path):
+    github = _make_clone(tmp_path)
+    (github / "g.txt").write_text("x")
+    _gitlab_clone(tmp_path)
+    (tmp_path / "gitlab" / "gl" / "l.txt").write_text("x")
+
+    cmd_push({"github": {"r": None}, "gitlab": {"gl": None}}, tmp_path,
+             dry_run=True, only="github")
+
+    out = capsys.readouterr().out
+    assert "github/r" in out
+    assert "gitlab/gl" not in out
+
+
+def test_status_unknown_platform_errors(capsys, tmp_path, monkeypatch):
+    import sys
+    from polygit.cli import main
+
+    _make_clone(tmp_path)
+    (tmp_path / ".pgit").write_text("github:\n  r:\n")
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(sys, "argv", ["pgit", "status", "--only", "bitbucket"])
+
+    with pytest.raises(SystemExit) as exc:
+        main()
+
+    assert exc.value.code == 1
+    err = capsys.readouterr().err
+    assert "bitbucket" in err
+    assert "github" in err

{polygit-0.4.0 → polygit-0.6.0}/uv.lock

@@ -117,7 +117,7 @@ wheels = [
 
 [[package]]
 name = "polygit"
-version = "0.4.0"
+version = "0.6.0"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },