tmuxpull 0.1.0__py3-none-any.whl

tmuxpull/__init__.py

@@ -0,0 +1,370 @@
+"""
+tmuxpull -- run `git pull --rebase --autostash` across every Git repo under
+the given roots, concurrently. Print a per-repo summary of what changed, and
+create a dedicated tmux session per repo with a rebase window showing `git status`.
+
+Usage:
+    tmuxpull [-d DEPTH] [-j JOBS] [--tmux {on,off}] [-v] [--dry-run] DIR [DIR ...]
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import re
+import shutil
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+import libtmux
+
+
+# Directories that are never a repo we want to descend into.
+_SKIP_DIRS: frozenset[str] = frozenset(
+    {
+        ".git",
+        "node_modules",
+        ".venv",
+        "venv",
+        "env",
+        "target",
+        "build",
+        "dist",
+        "__pycache__",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".tox",
+    }
+)
+
+# tmux session names cannot contain ':' or '.' but allow '/'. 
+# Use Unix-style paths since tmux runs in Unix-like environments.
+_UNSAFE_TMUX = re.compile(r"[:.\s]")
+
+
+# --------------------------------------------------------------------------- #
+# data model                                                                  #
+# --------------------------------------------------------------------------- #
+
+
+@dataclass(slots=True)
+class Repo:
+    path: Path  # absolute filesystem path
+    name: str   # display + tmux window name (posix-style relative path)
+
+
+@dataclass(slots=True)
+class Result:
+    repo: Repo
+    returncode: int
+    stdout: str
+    stderr: str
+    old_sha: str = ""
+    new_sha: str = ""
+    log_lines: list[str] = field(default_factory=list)
+    shortstat: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+    @property
+    def changed(self) -> bool:
+        return self.ok and bool(self.old_sha) and self.old_sha != self.new_sha
+
+    @property
+    def needs_attention(self) -> bool:
+        # A failed rebase leaves the repo in a state you have to intervene in
+        # (conflict markers, in-progress rebase, or an unpopped autostash).
+        return not self.ok
+
+    def summary_line(self) -> str:
+        if not self.ok:
+            tail = (self.stderr.strip().splitlines() or [f"exit {self.returncode}"])[-1]
+            return f"✗ FAIL: {tail}"
+        if not self.changed:
+            return "· up to date"
+        n = len(self.log_lines)
+        return f"✓ {n} commit{'s' if n != 1 else ''}  {self.shortstat}".rstrip()
+
+
+# --------------------------------------------------------------------------- #
+# repo discovery                                                              #
+# --------------------------------------------------------------------------- #
+
+
+def find_repos(roots: Iterable[str], max_depth: int) -> list[Repo]:
+    """Walk each root looking for directories containing a .git entry.
+
+    Prunes noise directories (see _SKIP_DIRS), enforces a max depth relative
+    to each root, and never descends into a repo (so nested submodules are
+    ignored -- typically what you want for a "pull everything" script).
+    """
+    out: list[Repo] = []
+    for root in roots:
+        top = Path(root).expanduser().resolve()
+        if not top.is_dir():
+            print(f"skip: {top} is not a directory", file=sys.stderr)
+            continue
+        base = len(top.parts)
+        for dirpath, dirs, _ in os.walk(top):
+            here = Path(dirpath)
+            depth = len(here.parts) - base
+            dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
+            if depth > max_depth:
+                dirs[:] = []
+                continue
+            if (here / ".git").exists():
+                dirs[:] = []
+                name = "." if here == top else here.relative_to(top).as_posix()
+                out.append(Repo(path=here, name=name))
+
+    # dedupe (overlapping roots)
+    seen: set[Path] = set()
+    uniq: list[Repo] = []
+    for r in out:
+        if r.path in seen:
+            continue
+        seen.add(r.path)
+        uniq.append(r)
+    return uniq
+
+
+# --------------------------------------------------------------------------- #
+# git                                                                         #
+# --------------------------------------------------------------------------- #
+
+
+async def _git(repo: Path, *args: str) -> tuple[int, str, str]:
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        "-C",
+        str(repo),
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    return proc.returncode, stdout.decode(errors="replace"), stderr.decode(errors="replace")
+
+
+async def rebase(repo: Repo, sem: asyncio.Semaphore) -> Result:
+    async with sem:
+        rc, out, err = 0, "", ""
+        _, old_sha, _ = await _git(repo.path, "rev-parse", "HEAD")
+        old_sha = old_sha.strip()
+        rc, out, err = await _git(repo.path, "pull", "--rebase", "--autostash")
+        _, new_sha, _ = await _git(repo.path, "rev-parse", "HEAD")
+        new_sha = new_sha.strip()
+
+        log_lines: list[str] = []
+        shortstat = ""
+        if rc == 0 and old_sha and new_sha and old_sha != new_sha:
+            _, log_out, _ = await _git(
+                repo.path,
+                "log",
+                "--oneline",
+                "--no-decorate",
+                f"{old_sha}..{new_sha}",
+            )
+            log_lines = [ln for ln in log_out.splitlines() if ln]
+            _, ss, _ = await _git(repo.path, "diff", "--shortstat", f"{old_sha}..{new_sha}")
+            shortstat = ss.strip()
+
+    return Result(
+        repo=repo,
+        returncode=rc,
+        stdout=out,
+        stderr=err,
+        old_sha=old_sha,
+        new_sha=new_sha,
+        log_lines=log_lines,
+        shortstat=shortstat,
+    )
+
+
+# --------------------------------------------------------------------------- #
+# tmux                                                                        #
+# --------------------------------------------------------------------------- #
+
+
+def _sanitize(name: str) -> str:
+    return _UNSAFE_TMUX.sub("_", name) or "rebase"
+
+
+def _make_session_name(repo: Repo) -> str:
+    """Create a tmux session name that looks like a Unix path to the repo."""
+    parent = repo.path.parent.name
+    repo_name = repo.path.name
+    
+    # Handle edge cases
+    if not parent or parent == "/":
+        session_name = repo_name
+    else:
+        # Use Unix-style forward slash (tmux runs in Unix-like environments)
+        session_name = f"{parent}/{repo_name}"
+    
+    return _sanitize(session_name)
+
+
+def open_repo_session(server: libtmux.Server, r: Result) -> str:
+    """Create or update a tmux session for a specific repo.
+    
+    Returns the session name for user reference.
+    """
+    session_name = _make_session_name(r.repo)
+    window_name = "rebase"
+    
+    # Try to get existing session
+    sess = server.sessions.get(session_name=session_name, default=None)
+    
+    if sess is None:
+        # Create new session with rebase as the first window
+        sess = server.new_session(
+            session_name=session_name,
+            window_name=window_name,
+            start_directory=str(r.repo.path),
+            attach=False,
+        )
+        pane = sess.active_pane
+    else:
+        # Session exists, add a new rebase window
+        # Check if rebase window already exists
+        existing_rebase = None
+        for window in sess.windows:
+            if window.name == window_name:
+                existing_rebase = window
+                break
+        
+        if existing_rebase:
+            # Rebase window exists, make it unique with timestamp
+            import time
+            window_name = f"rebase-{int(time.time()) % 10000}"
+        
+        pane = sess.new_window(
+            window_name=window_name,
+            start_directory=str(r.repo.path),
+        ).active_pane
+    
+    # Always land on git status to show current state
+    pane.send_keys("git status")
+    return session_name
+
+
+# --------------------------------------------------------------------------- #
+# main                                                                        #
+# --------------------------------------------------------------------------- #
+
+
+async def _run(repos: list[Repo], jobs: int) -> list[Result]:
+    sem = asyncio.Semaphore(jobs)
+    return await asyncio.gather(*(rebase(r, sem) for r in repos))
+
+
+def _print_report(results: list[Result], verbose: int) -> int:
+    fails = 0
+    width = max((len(r.repo.name) for r in results), default=0)
+    for r in results:
+        stream = sys.stdout if r.ok else sys.stderr
+        print(f"{r.repo.name:<{width}}  {r.summary_line()}", file=stream)
+        if verbose > 0 and r.changed:
+            preview = r.log_lines if verbose > 1 else r.log_lines[:3]
+            for ln in preview:
+                print(f"  {ln}", file=stream)
+            if verbose <= 1 and len(r.log_lines) > 3:
+                print(f"  ... +{len(r.log_lines) - 3} more", file=stream)
+        if not r.ok:
+            fails += 1
+    return fails
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        prog="tmuxpull",
+        description=(
+            "Concurrently `git pull --rebase --autostash` every Git repo under the "
+            "given roots. Print a per-repo summary of what changed, and create a "
+            "dedicated tmux session per repo with a rebase window."
+        ),
+    )
+    ap.add_argument(
+        "-d",
+        "--max-depth",
+        type=int,
+        default=2,
+        metavar="N",
+        help="Directory search depth (default: 2).",
+    )
+    ap.add_argument(
+        "-j",
+        "--jobs",
+        type=int,
+        default=min(8, (os.cpu_count() or 2) * 2),
+        metavar="N",
+        help="Max concurrent rebases (default: min(8, 2*CPU)).",
+    )
+    ap.add_argument(
+        "--tmux",
+        choices=("on", "off"),
+        default="on",
+        help="Create tmux sessions: on (default) or off.",
+    )
+
+    ap.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Show commit subjects. -v = top 3, -vv = all.",
+    )
+    ap.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="List repos that would be pulled, then exit.",
+    )
+    ap.add_argument(
+        "dirs",
+        nargs="+",
+        metavar="dir",
+        help="Root directories to scan for Git repos.",
+    )
+    args = ap.parse_args()
+
+    repos = find_repos(args.dirs, args.max_depth)
+    if not repos:
+        print("no git repos found", file=sys.stderr)
+        sys.exit(1)
+
+    if args.dry_run:
+        for r in repos:
+            print(r.path)
+        return
+
+    print(
+        f"rebasing {len(repos)} repo{'s' if len(repos) != 1 else ''} (jobs={args.jobs})...",
+        file=sys.stderr,
+    )
+
+    results = asyncio.run(_run(repos, args.jobs))
+    fails = _print_report(results, args.verbose)
+
+    tmux_wanted = args.tmux == "on"
+    if tmux_wanted and shutil.which("tmux") is None:
+        print("tmux not on PATH; skipping sessions", file=sys.stderr)
+    elif tmux_wanted:
+        server = libtmux.Server()
+        session_names = []
+        
+        for r in results:
+            session_name = open_repo_session(server, r)
+            session_names.append(session_name)
+        
+        if session_names:
+            print(f"\n{len(session_names)} tmux session(s) created:", file=sys.stderr)
+            for name in sorted(set(session_names)):
+                print(f"  tmux attach -t {name}", file=sys.stderr)
+
+    sys.exit(1 if fails else 0)

tmuxpull/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m tmuxpull` and the `tmuxpull` console script."""
+
+from tmuxpull import main
+
+if __name__ == "__main__":
+    main()

tmuxpull-0.1.0.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.5
+Name: tmuxpull
+Version: 0.1.0
+Summary: Concurrent git pull --rebase --autostash across multiple repos with tmux attention windows
+Project-URL: Homepage, https://github.com/nguyengg/tmuxpull
+Project-URL: Repository, https://github.com/nguyengg/tmuxpull.git
+Project-URL: Issues, https://github.com/nguyengg/tmuxpull/issues
+Author-email: Henry Nguyen <5065089+nguyengg@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: automation,concurrent,git,rebase,tmux
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Terminals
+Requires-Python: >=3.11
+Requires-Dist: libtmux>=0.35
+Description-Content-Type: text/markdown
+
+# tmuxpull
+
+Concurrent `git pull --rebase --autostash` across multiple Git repositories with tmux integration.
+
+## Quick Start
+
+### Run instantly with curl (no install)
+
+```bash
+# Python version — requires uv (https://docs.astral.sh/uv/)
+curl -fsSL https://raw.githubusercontent.com/nguyengg/tmuxpull/main/bin/rebase-all.py | uv run - ~/Workspaces
+
+# Zsh version — zero dependencies (just git + tmux)
+curl -fsSL https://raw.githubusercontent.com/nguyengg/tmuxpull/main/bin/rebase-all | zsh -s -- ~/Workspaces
+```
+
+### Install with curl (one-liner)
+
+```bash
+# Download the self-contained script to ~/.local/bin
+curl -fsSL https://raw.githubusercontent.com/nguyengg/tmuxpull/main/bin/rebase-all.py -o ~/.local/bin/tmuxpull && chmod +x ~/.local/bin/tmuxpull
+tmuxpull ~/Workspaces
+```
+
+The script carries its own dependency metadata (PEP 723), so with `uv` on your PATH it bootstraps its own environment on first run — no venv, no pip install.
+
+### Install from PyPI
+
+```bash
+# Install via pip/uv (recommended)
+pip install tmuxpull
+tmuxpull ~/Workspaces
+
+# Or install as a uv tool
+uv tool install tmuxpull
+tmuxpull ~/Workspaces
+```
+
+Both scan for Git repos under the given directories, pull with rebase concurrently, print a summary per repo, and open tmux windows for repos that need your attention (conflicts, failures, etc.).
+
+## Features
+
+- **Concurrent execution** with configurable job limits
+- **Smart repo discovery** with depth limits and noise filtering (skips `node_modules`, `.venv`, etc.)
+- **Per-repo summaries** showing commits pulled and file change stats (Python version)
+- **tmux integration** — opens windows for repos needing attention, landing on `git status`
+- **Multiple modes**: attention-only (default), all repos, or no tmux
+- **PEP 723 packaging** (Python) — zero-setup single file with dependencies declared inline
+
+## Usage
+
+```bash
+tmuxpull [-d DEPTH] [-j JOBS] [--tmux {all,attn,off}] 
+         [-s SESSION] [-v] [--dry-run] DIR [DIR ...]
+```
+
+### Options
+
+- `-d, --max-depth N` — Directory search depth (default: 2)
+- `-j, --jobs N` — Max concurrent rebases (default: min(8, 2×CPU))
+- `--tmux {all,attn,off}` — tmux windows for: all repos, attention-only (default), or none
+- `-s, --session NAME` — tmux session name (default: "rebase") 
+- `-v, --verbose` — Show commit subjects (-v = top 3, -vv = all)
+- `--dry-run` — List repos that would be processed, then exit
+
+### Examples
+
+```bash
+# Morning sync across your workspace
+tmuxpull ~/Workspaces ~/Projects
+
+# High concurrency, all repos get tmux windows
+tmuxpull -j 16 --tmux all ~/Code
+
+# Just print what would happen
+tmuxpull --dry-run ~/Projects
+
+# Verbose output showing commit messages  
+tmuxpull -v ~/Workspaces
+```
+
+## Output
+
+Per-repo summary lines:
+```
+my-project        ✓ 3 commits  8 files changed, 213 insertions(+), 41 deletions(-)
+other-repo        · up to date
+broken-thing      ✗ FAIL: could not apply autostash
+```
+
+Failed repos open tmux windows in the "rebase" session (or `-s NAME`), landing on `git status` so you see what's broken. Attach with `tmux attach -t rebase`.
+
+## Two Versions
+
+### `bin/rebase-all.py` (Recommended)
+
+- **Standard Python package** with proper console script entry point
+- Rich per-repo summaries with git log output and diffstat
+- Better error handling and progress reporting
+- Structured data model for repo state
+
+**Requirements**: Python 3.11+, tmux, git
+
+### `bin/rebase-all` (Fallback)
+
+- **Pure Zsh** — no Python dependencies
+- Basic summaries (commit count only, no diffstat)
+- Simpler concurrency model with job control
+
+**Requirements**: Zsh, tmux, git
+
+## Installation
+
+### From PyPI (Recommended)
+
+```bash
+# Install globally
+pip install tmuxpull
+
+# Or as a uv tool (isolated)
+uv tool install tmuxpull
+```
+
+### From Source
+
+```bash
+# Clone and install
+git clone https://github.com/nguyengg/tmuxpull.git
+cd tmuxpull
+pip install .
+
+# Or for development
+uv sync --dev
+```
+
+### Zsh Fallback
+
+For machines without Python, use the dependency-free Zsh script:
+```bash
+chmod +x bin/rebase-all
+ln -s $PWD/bin/rebase-all ~/.local/bin/
+```
+
+## Design
+
+Finds Git repos by walking the filesystem looking for `.git` directories, up to a configurable depth. Prunes common noise directories (`node_modules`, build artifacts, Python venvs) to avoid slow traversals.
+
+Rebases run concurrently via `asyncio` (Python) or Zsh job control, capped at a reasonable limit to avoid overwhelming git servers. Each repo is isolated — failures don't stop other repos.
+
+The tmux integration is the key workflow piece: clean repos just print their summary and disappear, while repos needing intervention (conflict resolution, stash conflicts, etc.) open interactive windows where you can fix things. `tmux attach -t rebase` becomes your "work queue" for the morning.
+
+## License
+
+MIT

tmuxpull-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+tmuxpull/__init__.py,sha256=rk9yOW2NjSURfZbNHwdl3M2xxKPcHs_T-2wKBMufJM8,11636
+tmuxpull/__main__.py,sha256=xDj_Ex52cF8R4KnmOZ50R4SbO8ngntkyB18rTc3Y09E,143
+tmuxpull-0.1.0.dist-info/METADATA,sha256=qGpWF37Wr18M6NACU-hOPDNtMvnwHUMec_pxzDoymuU,5975
+tmuxpull-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+tmuxpull-0.1.0.dist-info/entry_points.txt,sha256=-x4bLcj70nbF3N9cw1cPOymSn0mw6vZQPDd67CQiNbs,52
+tmuxpull-0.1.0.dist-info/licenses/LICENSE,sha256=B7s-ICTPZWDrB7_mo4xH90Zu-sI4VgspGkIXlVqZwxQ,1068
+tmuxpull-0.1.0.dist-info/RECORD,,

tmuxpull-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tmuxpull-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tmuxpull = tmuxpull.__main__:main

tmuxpull-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henry Nguyen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.