pulli 0.2.1__py3-none-any.whl

pulli/tree.py

@@ -0,0 +1,447 @@
+"""Render the repo tree to the terminal.
+
+Layout:
+
+  ~/code
+  ├── clones/
+  │   ├── herdr  ogulcancelik/herdr  master  ↓0 ↑0  ● clean
+  │   ├── pi     earendil-works/pi   main    ↓5 ↑0  ◐ dirty 2
+  │   └── ghostty  ghostty-org/ghostty  main  ↓0 ↑0  ● clean
+  ├── kontext.one/  devskale/kontext.one  main  ↓0 ↑3  ● clean
+  │   ├── klark0
+  │   └── python-utils
+  ...
+
+Conventions:
+  - Plain (non-repo) directories are shown with a trailing `/` and no status.
+  - Repos get a status line: remote, branch, ahead/behind, clean/dirty.
+  - A repo with no upstream (fresh init, detached HEAD, no remote) shows
+    `·  ·` instead of a misleading `↓0 ↑0`.
+  - A repo whose fetch failed shows `offline (stale)` — the numbers may be
+    out of date and we say so instead of implying freshness.
+  - Repos with an operation in progress (merge/rebase/bisect) are marked
+    and treated as unsafe to touch.
+  - Symlinks are suffixed with ` -> target` and a `(symlink)` marker.
+    A link whose target is also reachable under its real name is shown as
+    an alias, and never as a second pull target.
+  - Submodules are suffixed with `(submodule)`.
+  - Bare repos (`x.git/`) are shown but marked: no working tree, no pull.
+  - Errors are shown in red.
+
+Every value here comes from `RepoNode` fields filled in by `status.py`;
+this module never shells out to git. That keeps the walk fast (git runs
+once per repo during status collection, not again during rendering) and
+keeps the credential scrubbing in exactly one place.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+import sys
+import threading
+
+from .discovery import RepoNode, iter_repos
+
+# ANSI colors — kept minimal; degrade gracefully on non-TTY (we strip them).
+_RESET = "\x1b[0m"
+_DIM = "\x1b[2m"
+_BOLD = "\x1b[1m"
+_GREEN = "\x1b[32m"
+_YELLOW = "\x1b[33m"
+_RED = "\x1b[31m"
+_CYAN = "\x1b[36m"
+_MAGENTA = "\x1b[35m"
+
+_BARE_NOTE = "(bare repo — nothing to pull)"
+
+# Matches a single ANSI SGR escape sequence (color / style codes).
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _visible_width(s: str) -> int:
+    """Visible column count, ignoring ANSI escape sequences."""
+    return len(_ANSI_RE.sub("", s))
+
+
+def _clip_ansi(s: str, width: int) -> str:
+    """Clip `s` to `width` *visible* columns, preserving ANSI escape codes.
+
+    The live tree rewrites lines in place with cursor-up/down arithmetic that
+    assumes every line occupies exactly one terminal row. A line wider than
+    the terminal wraps onto a second row, and the arithmetic then lands on
+    the wrong row — corrupting the display (the `mytestdir` bug). Clipping to
+    the terminal width guarantees no line ever wraps.
+
+    If truncation cuts into a colored region we append a reset so the color
+    doesn't bleed into the next line.
+    """
+    if width <= 0 or _visible_width(s) <= width:
+        return s
+    out: list[str] = []
+    vis = 0
+    i = 0
+    n = len(s)
+    truncated = False
+    while i < n:
+        c = s[i]
+        if c == "\x1b":
+            # Copy the whole escape sequence through unchanged.
+            if i + 1 < n and s[i + 1] == "[":
+                j = i + 2
+                while j < n and not ("\x40" <= s[j] <= "\x7e"):
+                    j += 1
+                j += 1  # the final byte (letter)
+            else:
+                j = i + 1
+            out.append(s[i:j])
+            i = j
+        else:
+            if vis >= width:
+                truncated = True
+                break
+            out.append(c)
+            vis += 1
+            i += 1
+    if truncated:
+        out.append(_RESET)
+    return "".join(out)
+
+
+def _shorten_url(url: str) -> str:
+    """git@github.com:owner/repo.git -> owner/repo
+
+    Strips credentials (user:pass@ or token@) so secrets never hit the
+    terminal. This is the only place a remote URL becomes display text.
+    """
+    if not url:
+        return ""
+    # Strip userinfo from scheme://user:pass@host/path
+    if "://" in url:
+        scheme, rest = url.split("://", 1)
+        if "@" in rest:
+            rest = rest.split("@", 1)[1]
+        url = f"{scheme}://{rest}"
+    elif url.startswith("git@"):
+        # git@host:owner/repo.git — scp-like; 'git' is a username, not a
+        # secret. Drop the git@host: prefix for display.
+        url = url.split(":", 1)[1] if ":" in url else url
+    elif "@" in url and ":" in url.split("@", 1)[0]:
+        # user:pass@host:path — strip creds
+        url = url.split("@", 1)[1]
+    # For the common hosts, drop scheme+host so the display is just
+    # `owner/repo` — the same compact form as a scp-style `git@host:owner/repo`
+    # URL. A less common host keeps its name so the repo is identifiable.
+    for host in ("https://github.com/", "https://gitlab.com/",
+                 "https://bitbucket.org/", "http://github.com/",
+                 "http://gitlab.com/", "http://bitbucket.org/"):
+        if url.startswith(host):
+            url = url[len(host):]
+            break
+    if url.endswith(".git"):
+        url = url[: -len(".git")]
+    return url
+
+
+def _status_glyph(node: RepoNode) -> tuple[str, str]:
+    """Return (glyph, color) for the clean/dirty/error state."""
+    if node.error:
+        return "✗", _RED
+    if node.dirty or node.operation:
+        return "◐", _YELLOW
+    return "●", _GREEN
+
+
+def _ahead_behind(node: RepoNode) -> str:
+    """↓behind ↑ahead, or a clear placeholder when there is no upstream.
+
+    Showing `↓0 ↑0` for a repo with no upstream reads as "in sync with
+    something", which is a lie — there is nothing to be in sync with.
+    """
+    if not node.upstream:
+        return "·  ·"
+    return f"↓{node.behind or 0} ↑{node.ahead or 0}"
+
+
+def _repo_tail_parts(node: RepoNode, C) -> list[str]:
+    """The status columns for a repo node, as a list of aligned-able parts.
+
+    Returns `[url, branch, ahead/behind, state]` so a flat renderer can pad
+    the url column to a fixed width before joining. The tree renderer just
+    joins them with two spaces.
+    """
+    if node.error:
+        return [C(f"✗ {node.error}", _RED)]
+
+    url = _shorten_url(node.url)
+    parts = [
+        C(url, _DIM) if url else "",
+        C(node.branch or "?", _BOLD),
+        _ahead_behind(node),
+    ]
+
+    if node.operation:
+        state = C(f"◐ {node.operation} — skipping", _YELLOW)
+    elif node.fetch_failed:
+        # Fetch didn't work, so ↓↑ may be stale. Say so rather than lie.
+        state = C(f"◐ offline — {node.fetch_reason or 'unreachable'}", _YELLOW)
+    else:
+        glyph, gcolor = _status_glyph(node)
+        state = (
+            C(f"{glyph} dirty {len(node.dirty_files)}", _YELLOW)
+            if node.dirty
+            else C(f"{glyph} clean", gcolor)
+        )
+
+    parts.append(state)
+    return parts
+
+
+def _repo_tail(node: RepoNode, C) -> str:
+    """The status column for a repo node: remote, branch, ↓↑, glyph + state."""
+    return "  ".join(p for p in _repo_tail_parts(node, C) if p)
+
+
+def _label(node: RepoNode, C) -> str:
+    name = node.name
+    if node.is_submodule:
+        return C(name, _CYAN) + C(" (submodule)", _DIM)
+    if node.is_symlink:
+        s = C(name, _MAGENTA) + C(" -> " + (node.symlink_target or ""), _DIM)
+        # A link that is the only route to its target is just a
+        # symlink. One whose target is also listed under its real name
+        # is an alias: it shows a second name for a repo that appears
+        # elsewhere in the tree, and must not look like a second one.
+        return s + (C(" (alias)", _DIM) if node.is_alias else C(" (symlink)", _DIM))
+    return name
+
+
+def _build_lines(
+    root: RepoNode,
+    C,
+    tail,
+) -> tuple[list[str], dict[int, int], dict[int, str]]:
+    """Build the tree lines.
+
+    `tail(node)` renders the status column for a repo node (the batch
+    renderer passes `_repo_tail`; the live renderer passes a placeholder).
+    Returns `(lines, repo_line, repo_base)`:
+      * `lines` — the rendered strings, one per row;
+      * `repo_line` — maps `id(node)` -> line index for every repo node;
+      * `repo_base` — maps `id(node)` -> the `prefix+connector+name` part of
+        that line, so a live renderer can swap just the status tail in place.
+    """
+    lines: list[str] = []
+    repo_line: dict[int, int] = {}
+    repo_base: dict[int, str] = {}
+
+    # Root header — annotated too when the root is itself a repo, so the
+    # head of the tree isn't a bare path with no status next to it.
+    root_label = C(str(root.link_path or root.path), _BOLD)
+    header = root_label
+    if root.is_repo:
+        header += "  " + tail(root)
+        repo_line[id(root)] = 0
+        repo_base[id(root)] = root_label
+    elif root.is_bare:
+        header += "  " + C(_BARE_NOTE, _DIM)
+    lines.append(header)
+
+    def render_node(node: RepoNode, prefix: str, is_last: bool) -> None:
+        connector = "└── " if is_last else "├── "
+        name = _label(node, C)
+
+        if node.is_alias:
+            # The target is listed under its real name elsewhere; this is a
+            # second name for it, not a second repo to pull. No status
+            # columns — there is nothing here to report.
+            lines.append(f"{prefix}{connector}{name}")
+        elif node.is_repo:
+            base = f"{prefix}{connector}{name}"
+            lines.append(base + "  " + tail(node))
+            repo_line[id(node)] = len(lines) - 1
+            repo_base[id(node)] = base
+        elif node.is_bare:
+            lines.append(f"{prefix}{connector}{name}/  {C(_BARE_NOTE, _DIM)}")
+        else:
+            # plain directory — show with trailing /, no status
+            lines.append(f"{prefix}{connector}{C(name + '/', _DIM)}")
+
+        child_prefix = prefix + ("    " if is_last else "│   ")
+        for i, child in enumerate(node.children):
+            render_node(child, child_prefix, i == len(node.children) - 1)
+
+    last = len(root.children) - 1
+    for i, child in enumerate(root.children):
+        render_node(child, "", i == last)
+
+    return lines, repo_line, repo_base
+
+
+def _build_flat_lines(
+    root: RepoNode,
+    C,
+    tail,
+) -> tuple[list[str], dict[int, int], dict[int, str]]:
+    """Build a flat list: one line per repo, no tree structure.
+
+    `tail(node)` renders the status column for a repo node. Returns
+    `(lines, repo_line, repo_base)` with the same contract as
+    `_build_lines`, so a live renderer can swap a repo's status in place.
+    Repos are ordered by display path, so two identical runs are identical.
+    """
+    lines: list[str] = []
+    repo_line: dict[int, int] = {}
+    repo_base: dict[int, str] = {}
+    repos = sorted(iter_repos(root), key=lambda n: n.rel)
+    if not repos:
+        return lines, repo_line, repo_base
+    # Pad every path to the widest one so the status columns line up like a
+    # table instead of starting wherever the previous path happened to end.
+    path_width = max(_visible_width(C(n.rel, _DIM)) for n in repos)
+    # Pad the url column too, so branch / ahead-behind / state also align.
+    url_width = max((_visible_width(_shorten_url(n.url)) for n in repos), default=0)
+    for n in repos:
+        base = C(n.rel, _DIM)
+        padded = base + " " * (path_width - _visible_width(base))
+        # Rebuild the tail with a url column padded to a fixed width. Always
+        # emit the url cell (even when empty) so the branch column lines up
+        # for repos that have no remote too.
+        cols = _repo_tail_parts(n, C)
+        if len(cols) >= 4:
+            cols[0] = cols[0] + " " * (url_width - _visible_width(cols[0]))
+        text = "  ".join(c for c in cols if c)
+        lines.append(padded + "  " + text)
+        repo_line[id(n)] = len(lines) - 1
+        repo_base[id(n)] = padded
+    return lines, repo_line, repo_base
+
+
+def render(root: RepoNode, *, use_color: bool = True) -> str:
+    """Render the full tree as a string."""
+
+    def C(s: str, *codes: str) -> str:
+        if not use_color:
+            return s
+        return "".join(codes) + s + _RESET
+
+    lines, _, _ = _build_lines(root, C, lambda n: _repo_tail(n, C))
+    return "\n".join(lines)
+
+
+def render_flat(root: RepoNode, *, use_color: bool = True) -> str:
+    """Render a flat list of repos (one line each), not the tree."""
+
+    def C(s: str, *codes: str) -> str:
+        if not use_color:
+            return s
+        return "".join(codes) + s + _RESET
+
+    lines, _, _ = _build_flat_lines(root, C, lambda n: _repo_tail(n, C))
+    return "\n".join(lines)
+
+
+class LiveTree:
+    """Streams the tree to a terminal.
+
+    Prints the skeleton immediately — every repo line shows a dim `…` where
+    its status will go — then rewrites each repo's line in place as its
+    status becomes available. The final output is identical to `render()`,
+    it just appears incrementally instead of all at once after a multi-second
+    fetch.
+
+    Only meaningful when the stream is a real terminal. Off a TTY it falls
+    back to printing the fully-rendered tree once, and `update()` becomes a
+    no-op, so it is safe to construct anywhere.
+    """
+
+    def __init__(self, root: RepoNode, *, use_color: bool = True, stream=None,
+                 flat: bool = False) -> None:
+        self.stream = stream if stream is not None else sys.stdout
+        self.use_color = use_color
+        self._lock = threading.Lock()
+        # Terminal width: every rendered line is clipped to this so nothing
+        # wraps. A wrapped line is two rows, which breaks the cursor
+        # arithmetic the in-place rewrite relies on.
+        self._width = self._terminal_width()
+
+        def C(s: str, *codes: str) -> str:
+            if not use_color:
+                return s
+            return "".join(codes) + s + _RESET
+
+        self._C = C
+        self._flat = flat
+        # When flat, pad the url column so branch / ahead-behind / state
+        # align; store the width so update() can match the skeleton.
+        self._url_width = (
+            max((_visible_width(_shorten_url(c.url)) for c in iter_repos(root)), default=0)
+            if flat else 0
+        )
+        builder = _build_flat_lines if flat else _build_lines
+
+        if not self._is_tty():
+            # Not a real terminal: there is no in-place cursor control, so
+            # streaming is impossible. Print the skeleton (with `…`
+            # placeholders) once and leave update() inert. The CLI only uses
+            # LiveTree on a TTY, so this path is defensive.
+            self._active = False
+            lines, repo_line, repo_base = builder(root, C, lambda n: C("…", _DIM))
+            self.lines = [_clip_ansi(line, self._width) for line in lines]
+            self.repo_line = repo_line
+            self.repo_base = repo_base
+            self._bottom = len(self.lines)
+            self._print_skeleton()
+            return
+
+        self._active = True
+        lines, repo_line, repo_base = builder(root, C, lambda n: C("…", _DIM))
+        self.lines = [_clip_ansi(line, self._width) for line in lines]
+        self.repo_line = repo_line
+        self.repo_base = repo_base
+        self._bottom = len(self.lines)
+        self._print_skeleton()
+
+    def _is_tty(self) -> bool:
+        try:
+            return self.stream.isatty()
+        except (AttributeError, OSError):
+            return False
+
+    def _terminal_width(self) -> int:
+        """Columns of the terminal, or a sane default when unknown."""
+        try:
+            return shutil.get_terminal_size().columns
+        except (OSError, ValueError):
+            return 80
+
+    def _print_skeleton(self) -> None:
+        for line in self.lines:
+            self.stream.write(line + "\n")
+        self.stream.flush()
+
+    def update(self, node: RepoNode) -> None:
+        """Swap a repo's `…` placeholder for its real status, in place."""
+        if not self._active:
+            return
+        nid = id(node)
+        i = self.repo_line.get(nid)
+        if i is None:
+            return
+        cols = _repo_tail_parts(node, self._C)
+        if self._flat and len(cols) >= 4:
+            cols[0] = cols[0] + " " * (self._url_width - _visible_width(cols[0]))
+        text = self.repo_base[nid] + "  " + "  ".join(c for c in cols if c)
+        text = _clip_ansi(text, self._width)
+        with self._lock:
+            self._rewrite(i, text)
+
+    def _rewrite(self, i: int, text: str) -> None:
+        """Rewrite line `i` in place, then restore the cursor to the bottom."""
+        up = self._bottom - i
+        if up > 0:
+            self.stream.write(f"\x1b[{up}A")
+        self.stream.write("\r\x1b[2K" + text)
+        if up > 0:
+            self.stream.write(f"\x1b[{up}B")
+        self.stream.write("\r")
+        self.stream.flush()

pulli-0.2.1.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.5
+Name: pulli
+Version: 0.2.1
+Summary: Walk a directory tree, show git repos with status, and fast-forward the ones that are behind upstream.
+Author: Stefan Waldherr
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,developer-tools,git,pull,status
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pulli
+
+Discover git repositories under a directory, show their status, and
+fast-forward the ones that are behind upstream.
+
+## Install
+
+```bash
+uv tool install git+https://github.com/devskale/pulli
+# or
+pipx install git+https://github.com/devskale/pulli
+```
+
+Both put `pulli` on your PATH (`~/.local/bin/pulli`). To install a local
+checkout instead (development):
+
+```bash
+cd ~/code/pulli
+uv tool install --force .
+```
+
+## Usage
+
+```bash
+pulli                          # status tree of the current dir
+pulli ~/code                   # status tree of ~/code  (= `pulli tree ~/code`)
+pulli --no-fetch ~/code        # flags may come before or after the path
+pulli pull                     # pull the repos that are behind
+pulli pull --dry-run ~/code    # show what would be pulled, don't pull
+```
+
+### `tree` (default)
+
+By default `pulli` prints a **flat list of the repos only** — one line per
+repo, sorted by path — with no directory scaffolding, no `node_modules`/
+`.claude`/`dist` noise. Pass `--tree` to get the full directory tree
+instead (plain dirs, pruned dirs, symlinks, submodules, and the box-drawing
+connectors).
+
+| flag | effect |
+| --- | --- |
+| `--tree` | show the full directory tree instead of the flat repo list |
+| `--no-fetch` | don't fetch remotes before showing status |
+| `--no-symlinks` | don't follow symlinks (default: follow, marked) |
+| `--max-depth N` | limit recursion (default: 50) |
+| `--no-color` | disable ANSI colours (also implied off a TTY) |
+| `--json` | one JSON object per line, for scripts |
+
+Fetches run in parallel by default, so ahead/behind is current, and each is
+bounded by a short timeout — if you're offline (on a train) unreachable
+remotes are reported as `offline` and the tree still renders.
+
+While remotes are being fetched, a spinner animates on stderr with live
+progress (`⠋ Fetching remotes… 3/8`), so a multi-second fetch never looks
+frozen. The spinner only appears on a real terminal; when output is piped
+or captured (`pulli | less`, CI, scripts) it is a no-op and the output stays
+byte-clean. `--no-color` disables the spinner's colouring too.
+
+### `pull`
+
+| flag | effect |
+| --- | --- |
+| `--dry-run` | decide and report, change nothing |
+| `--no-fetch` | use local refs only (faster, may be stale) |
+| `--json` | the same decision as data; implies `--dry-run` |
+| `--no-color`, `--no-symlinks`, `--max-depth` | as above |
+
+Fetches every repo first, then fast-forwards the ones that are behind.
+
+## What `pull` does and does not touch
+
+Every rule below is a **skip, never a force** — pulli will not destroy or
+corrupt work to make progress.
+
+| repo state | action |
+| --- | --- |
+| behind upstream, clean | `git pull --ff-only` |
+| up to date | nothing (silent) |
+| ahead only | nothing — local commits need a *push*, not a pull |
+| uncommitted changes | skipped, reported |
+| diverged (ahead **and** behind) | skipped — a fast-forward is impossible; merge or rebase is your call |
+| merge / rebase / bisect in progress | skipped, reported — never touched |
+| no upstream (detached HEAD, no remote) | nothing to pull |
+| remote unreachable | reported as `offline`; **not** a failure |
+| broken repo | reported; exit code 1 |
+
+`--ff-only` is the important part: a plain `git pull` can *create* a merge
+commit (and a merge conflict) in a repo you never touched. `--ff-only`
+refuses instead.
+
+Exit code is `0` when nothing needs you, `1` on a broken repo or a failed
+pull. Being offline is not a failure.
+
+```
+$ pulli pull --dry-run ~/code
+  ↕ aiuis/pi-gui                ↓4 ↑2   diverged — needs merge or rebase, skipping
+  ◐ www/chopdok                 ↓5      dirty 1 (MERGE-REVIEW.md), skipping pull
+  ↑ throway                     ↑1      ↑1 ahead (not pushed)
+  ◐ klark0                              merge in progress — skipping pull
+  ↓ chopdok                     ↓5      would pull
+
+Dry run — no pulls performed.
+
+Would pull 1 repo(s).
+```
+
+## What the output shows
+
+### Flat list (default)
+
+```
+clones/pi  earendil-works/pi  main  ↓0 ↑0  ● clean
+clones/gogcli  openclaw/gogcli  main  ↓0 ↑0  ◐ dirty 5
+kontext.one  devskale/kontext.one  main  ↓0 ↑0  ◐ dirty 5
+```
+
+Each line is `path  remote  branch  ↓behind ↑ahead  state`. Repos are
+sorted by path, so a run is reproducible.
+
+### Tree (`--tree`)
+
+```
+~/code
+├── clones/
+│   ├── herdr    ogulcancelik/herdr    master  ↓0 ↑0  ● clean
+│   ├── pi       earendil-works/pi     main    ↓33 ↑0 ● clean
+│   └── gogcli   openclaw/gogcli       main    ↓0 ↑0  ◐ dirty 5
+├── handoffs -> code/skaleshare/handoffs (alias)
+├── kontext.one  devskale/kontext.one  main    ↓0 ↑0  ◐ dirty 5
+│   ├── klark0     devskale/klark0      dev     ↓0 ↑0  ● clean
+│   └── python-utils (submodule)                   ↓0 ↑0  ● clean
+└── backups/
+    └── model-proxy.git/  (bare repo — nothing to pull)
+```
+
+## What the tree shows
+
+```
+~/code
+├── clones/
+│   ├── herdr    ogulcancelik/herdr    master  ↓0 ↑0  ● clean
+│   ├── pi       earendil-works/pi     main    ↓33 ↑0 ● clean
+│   └── gogcli   openclaw/gogcli       main    ↓0 ↑0  ◐ dirty 5
+├── handoffs -> code/skaleshare/handoffs (alias)
+├── kontext.one  devskale/kontext.one  main    ↓0 ↑0  ◐ dirty 5
+│   ├── klark0     devskale/klark0      dev     ↓0 ↑0  ● clean
+│   └── python-utils (submodule)                   ↓0 ↑0  ● clean
+└── backups/
+    └── model-proxy.git/  (bare repo — nothing to pull)
+```
+
+- **`↓N ↑M`** — commits behind / ahead of upstream; `·  ·` means there is
+  no upstream to compare against (a fresh `git init`, a detached HEAD, a
+  remote-less clone), which is not the same as "in sync"
+- **`●` clean / `◐` dirty N / `✗` error** — `◐ offline` means the fetch
+  failed, so the numbers may be stale
+- **symlinks** are followed by default and marked; one whose target is also
+  reachable under its real name is shown as an `(alias)` and is never a
+  second pull target. `--no-symlinks` skips them
+- **submodules** are their own nodes, marked `(submodule)`
+- **nested repos** (a repo inside another repo) are found and shown
+- **bare repos** (`x.git/`) have no working tree: marked, never pulled
+- **credentials** in remote URLs (tokens, `user:pass@`) are stripped before
+  display
+
+## Development
+
+```bash
+uv run --extra dev pytest     # 45 tests, all against real git repos in tmpdirs
+```
+
+Tests build actual repositories in every state pulli reasons about
+(behind, ahead, diverged, dirty, detached, mid-merge, offline, bare,
+symlinked, vendored) and assert on the *decision*, not the formatting —
+plus a cross-check that ahead/behind matches what `git rev-list` reports.
+
+## Layout
+
+```
+src/pulli/
+├── cli.py        # argparse entry point (tree + pull subcommands)
+├── discovery.py  # tree walk: repos, nested repos, submodules, symlinks, bare
+├── status.py     # per-repo git status (branch, ahead/behind, dirty, operation)
+├── pull.py       # the decision: what to skip, what to fast-forward
+└── tree.py       # ANSI tree renderer with credential scrubbing
+```
+
+`status.py` is the only module that shells out for status; `tree.py` renders
+from the fields it fills in. That keeps git to one call per repo and keeps
+credential scrubbing in exactly one place.

pulli-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+pulli/__init__.py,sha256=dro1-yY3kwnakVo6FgLmEcu1wy9Gk0Fw9CAFjn5F4XA,95
+pulli/cli.py,sha256=I2AYZKnCYAgzBNQXOeqAlw4GpKHCCBGafaZwjM9eO_4,9843
+pulli/discovery.py,sha256=PTShA9NCGTJww5i0WFihVesx86-LW0jvY-nJGhBXnjI,18560
+pulli/pull.py,sha256=ANzXceOF1Lw_UFBB0UkxXBTIk1ixEsDabmS9noT_y8k,9980
+pulli/spinner.py,sha256=hEXLOuJf6271TvSH1yqnoc2cKVz8vJfu260u7qEShWQ,3795
+pulli/status.py,sha256=L75DyGBlrBj-fCon85h9m17uVN6i7mr13t-BSqj-Inw,16849
+pulli/tree.py,sha256=gODfKz4bVwxWqWs045YlvVPSyCPZcF0xLBe5yZ62g8o,16729
+pulli-0.2.1.dist-info/METADATA,sha256=VdwdjvgP2Fh4IueqrBukUq7lmrmVryfoMXp8JtxwwYc,8053
+pulli-0.2.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pulli-0.2.1.dist-info/entry_points.txt,sha256=2Co7Jl-YHCLalGvzeciA_4DvFD-1N4JIG48TMUzZAVQ,41
+pulli-0.2.1.dist-info/licenses/LICENSE,sha256=i3i8bBdnKsy4kZ3aSW0pDOtU8GG69Vuu1irJDYhLRNw,1072
+pulli-0.2.1.dist-info/RECORD,,

pulli-0.2.1.dist-info/WHEEL

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

pulli-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pulli = pulli.cli:main