pulli 0.2.13__tar.gz → 0.2.14__tar.gz

{pulli-0.2.13 → pulli-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pulli
-Version: 0.2.13
+Version: 0.2.14
 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

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/__init__.py

@@ -1,2 +1,2 @@
 """pulli — discover git repos under a root and report their status."""
-__version__ = "0.2.13"
+__version__ = "0.2.14"

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/cli.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -22,18 +23,10 @@ from . import __version__
 from .update import update_hint
 from .discovery import discover, iter_repos, set_rels
 from .pull import pull
-from .status import collect_status, fetch_all, fetch_and_status
+from .status import collect_incoming, collect_status, fetch_all, fetch_and_status
 from .tree import LiveTree, render, render_flat
 from .style import BOLD, RESET
 
-# Flags that belong to a subcommand. Used by _inject_tree to decide whether
-# a leading argument is a subcommand or a path/flag for the default one.
-_TREE_FLAGS = {
-    "--no-symlinks", "--no-fetch", "--no-color", "--max-depth",
-    "--dry-run", "--json", "--tree",
-}
-_PULL_FLAGS = {"--no-color", "--dry-run", "--json", "--no-fetch"}
-
 SUBCOMMANDS = ("tree", "pull", "update")
 
 class _VersionAction(argparse.Action):
@@ -257,21 +250,23 @@ def _run_update(args) -> int:
         print(f"pulli {__version__} → {latest} would be installed. Run: pulli update")
         return 0
 
-    exe = Path(sys.argv[0]).resolve()
-    candidates: list[tuple[str, list[str]]] = []
-    if ".local/bin" in str(exe) or True:  # uv tool and pipx both live here
-        candidates.append(("uv", ["uv", "tool", "upgrade", "pulli"]))
-        candidates.append(("pipx", ["pipx", "upgrade", "pulli"]))
-    import shutil
-    for name, cmd in candidates:
-        if shutil.which(cmd[0]):
-            print(f"pulli {__version__} → {latest} (via {name})")
-            rc = subprocess.run(cmd).returncode
-            if rc == 0:
-                print(f"Updated to pulli {latest}.")
-            return rc
+    # uv tool and pipx installs are indistinguishable by path (both land
+    # in ~/.local/bin), so try each installer found on PATH — and keep
+    # going when one fails: upgrading with the wrong tool errors out
+    # instead of pretending to succeed, and the right one may be next.
+    for name, cmd in (
+        ("uv", ["uv", "tool", "upgrade", "pulli"]),
+        ("pipx", ["pipx", "upgrade", "pulli"]),
+    ):
+        if not shutil.which(cmd[0]):
+            continue
+        print(f"pulli {__version__} → {latest} (via {name})")
+        rc = subprocess.run(cmd).returncode
+        if rc == 0:
+            print(f"Updated to pulli {latest}.")
+            return 0
     print(
-        f"pulli {latest} is available, but no uv/pipx found. Update manually, e.g.:\n"
+        f"pulli {latest} is available, but no installer succeeded. Update manually, e.g.:\n"
         f"  pip install --upgrade pulli",
         file=sys.stderr,
     )
@@ -374,6 +369,8 @@ def _run_tree(args) -> int:
         if not args.no_fetch:
             fetch_all(repos, quiet=True, use_color=_use_color(args))
         collect_status(tree)
+        if args.verbose:
+            collect_incoming(repos)
         _print_json(tree)
         return 0
 
@@ -382,7 +379,12 @@ def _run_tree(args) -> int:
     # Filters decide on fetched status, so they cannot stream: the skeleton
     # is printed before anything is known. Run the batch path instead.
     filtered = bool(getattr(args, "behind", False) or getattr(args, "attention", False))
-    if sys.stdout.isatty() and not filtered:
+    # -v needs the batch path too: the live tree rewrites each repo's line
+    # in place under a fixed row budget, and extra commit lines would break
+    # that arithmetic. Print complete, once — the point of -v is reading
+    # the commits, not watching them arrive.
+    verbose = bool(getattr(args, "verbose", False))
+    if sys.stdout.isatty() and not filtered and not verbose:
         # Stream: print the skeleton immediately, then fill each repo's
         # status line in as it becomes ready — no blank-screen wait.
         live = LiveTree(tree, use_color=use_color, flat=flat)
@@ -410,6 +412,8 @@ def _run_tree(args) -> int:
         if not args.no_fetch:
             fetch_all(repos, quiet=True, use_color=use_color)
         collect_status(tree)
+        if verbose:
+            collect_incoming(repos)
         if flat:
             shown = list(iter_repos(tree))
             if args.behind:
@@ -425,12 +429,13 @@ def _run_tree(args) -> int:
                 what = "behind" if args.behind else "needing attention"
                 print(f"No repos {what} under {args.link_root}")
                 return 0
-            print(render_flat(tree, use_color=use_color, repos=shown))
+            print(render_flat(tree, use_color=use_color, repos=shown,
+                              verbose=verbose))
             if not args.no_summary:
                 print()
                 print(_summary(shown, use_color))
         else:
-            print(render(tree, use_color=use_color))
+            print(render(tree, use_color=use_color, verbose=verbose))
     return 0
 
 
@@ -479,6 +484,7 @@ def _node_dict(n) -> dict:
         "operation": n.operation,
         "fetch_failed": n.fetch_failed or None,
         "error": n.error,
+        "incoming": n.incoming or None,
     }
 
 

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/discovery.py

@@ -57,6 +57,9 @@ class RepoNode:
     fetch_failed: bool = False  # fetch did not succeed (offline / unreachable)
     fetch_reason: str | None = None  # why the fetch failed
     error: str | None = None
+    # incoming commits (git log --oneline HEAD..upstream), filled in only
+    # when the caller asked for -v — one git call per behind repo.
+    incoming: list[str] = field(default_factory=list)
 
     def set_rel(self, root: Path) -> None:
         """Display path relative to `root`.
@@ -243,6 +246,53 @@ def discover(
     return root_node
 
 
+def _link_child(
+    node: RepoNode,
+    link: Path,
+    name: str,
+    display: Path,
+    visited: set[Path],
+) -> RepoNode | None:
+    """Record one symlink entry as a child of `node`. Shared by every
+    pass of the link walk.
+
+    A link whose target was already walked is an *alias*: the directory
+    exists here, but its repo is the one already listed elsewhere. Show
+    the link so the tree still reflects what is on disk, but not as a
+    second pull target — `pull` must never fast-forward the same work
+    tree twice. Returns None when the link is unusable (broken, not a
+    dir, unreadable).
+    """
+    try:
+        target = link.resolve(strict=True)
+    except (OSError, RuntimeError):
+        return None
+    if not target.is_dir():
+        return None
+    already = target in visited
+    if not already:
+        visited.add(target)
+    try:
+        is_repo = _is_git_dir(target)
+    except OSError:
+        return None
+    child = RepoNode(
+        path=target,
+        link_path=display,
+        name=name,
+        depth=node.depth + 1,
+        parent=node,
+        is_symlink=True,
+        symlink_target=_readlink(link),
+        is_repo=is_repo and not already,
+        is_alias=already,
+    )
+    node.children.append(child)
+    if is_repo and not already:
+        _add_submodules(child, target, display, node.depth + 1, visited)
+    return child
+
+
 def _walk_links(
     node: RepoNode,
     real_dir: Path,
@@ -286,9 +336,15 @@ def _walk_links(
                 # case) — but only one level of plain-dir descent, so a
                 # repo's src/ tree is not pointlessly scanned. The dir
                 # becomes a real node so links land under it, not under
-                # the repo root.
+                # the repo root — unless the first walk already recorded
+                # it (a plain dir outside a repo is a node there): then
+                # the links join the existing node, or the tree shows the
+                # same directory twice.
                 if link.is_dir() and not _is_pruned(name):
-                    dir_node = RepoNode(
+                    existing = next(
+                        (c for c in node.children if c.path == link), None
+                    )
+                    dir_node = existing if existing is not None else RepoNode(
                         path=link,
                         link_path=display_dir / name,
                         name=name,
@@ -297,65 +353,33 @@ def _walk_links(
                     )
                     _walk_links_plain(dir_node, link, display_dir / name,
                                       max_depth, visited)
-                    if dir_node.children:
+                    if existing is None and dir_node.children:
                         node.children.append(dir_node)
                 continue
-            target = link.resolve(strict=True)
-        except (OSError, RuntimeError):
-            continue
-        if not target.is_dir():
-            continue
-
-        display = display_dir / name
-        already = target in visited
-        if not already:
-            visited.add(target)
-
-        try:
-            is_repo = _is_git_dir(target)
         except OSError:
             continue
 
-        # A link whose target was already walked is an *alias*: the
-        # directory exists here, but its repo is the one already listed
-        # elsewhere. Show the link so the tree still reflects what is on
-        # disk, but not as a second pull target — `pull` must never
-        # fast-forward the same work tree twice.
-        child = RepoNode(
-            path=target,
-            link_path=display,
-            name=name,
-            depth=node.depth + 1,
-            parent=node,
-            is_symlink=True,
-            symlink_target=_readlink(link),
-            is_repo=is_repo and not already,
-            is_alias=already,
-        )
-        node.children.append(child)
-
-        if is_repo and not already:
-            _add_submodules(child, target, display, node.depth + 1, visited)
-        if not already:
-            _walk_links(child, target, display, max_depth, visited)
+        child = _link_child(node, link, name, display_dir / name, visited)
+        # Expand a fresh link target in place — aliases are listed under
+        # their real name already, and expanding them would duplicate the
+        # subtree.
+        if child is not None and not child.is_alias:
+            _walk_links(child, child.path, display_dir / name,
+                        max_depth, visited)
 
     node.children.sort(key=lambda c: c.name.lower())
 
 
-def _walk_links_plain(
+def _record_direct_links(
     node: RepoNode,
     real_dir: Path,
     display_dir: Path,
-    max_depth: int,
     visited: set[Path],
 ) -> None:
-    """Look for symlinks inside a plain dir the first walk never recorded
-    (plain dirs inside a repo are skipped there). Records only the links
-    themselves as children of `node` — the plain dir stays invisible, so the
-    tree does not grow a directory per level of indirection.
+    """Each symlink directly inside `real_dir` becomes a child of `node`.
 
-    Bounded to one level: the `.links/` layout is one dir of links; a full
-    recursive scan of a repo's working tree would be noise and cost.
+    Terminal: never descends into plain dirs and never expands link
+    targets — those are `_walk_links_plain`'s and `_walk_links`' jobs.
     """
     try:
         entries = sorted(os.listdir(real_dir), key=lambda s: s.lower())
@@ -368,35 +392,60 @@ def _walk_links_plain(
         try:
             if not link.is_symlink():
                 continue
-            target = link.resolve(strict=True)
-        except (OSError, RuntimeError):
+        except OSError:
             continue
-        if not target.is_dir():
+        _link_child(node, link, name, display_dir / name, visited)
+    node.children.sort(key=lambda c: c.name.lower())
+
+
+def _walk_links_plain(
+    node: RepoNode,
+    real_dir: Path,
+    display_dir: Path,
+    max_depth: int,
+    visited: set[Path],
+) -> None:
+    """Look for links inside a plain dir the first walk never recorded
+    (plain dirs inside a repo are skipped there).
+
+    Records the dir's direct symlinks as children of `node` — and, one
+    level deeper (depth permitting), the direct symlinks of its plain
+    subdirs. That second level is the `.links/` layout *inside a repo*:
+    those links are the whole point of the layout, and without the
+    descent a repo found by the normal walk never showed them, while the
+    same repo reached via a symlink did — the path you took decided
+    what you saw.
+
+    Still bounded: the descent never goes below that one extra level,
+    and plain dirs become nodes only when they hold links, so the tree
+    does not grow a directory per level of indirection.
+    """
+    _record_direct_links(node, real_dir, display_dir, visited)
+    if node.depth + 2 > max_depth:
+        return
+    try:
+        entries = sorted(os.listdir(real_dir), key=lambda s: s.lower())
+    except OSError:
+        return
+    for name in entries:
+        if name == ".git":
             continue
-        display = display_dir / name
-        already = target in visited
-        if not already:
-            visited.add(target)
+        d = real_dir / name
         try:
-            is_repo = _is_git_dir(target)
+            if d.is_symlink() or not d.is_dir() or _is_pruned(name):
+                continue
         except OSError:
             continue
-        child = RepoNode(
-            path=target,
-            link_path=display,
+        sub = RepoNode(
+            path=d,
+            link_path=display_dir / name,
             name=name,
             depth=node.depth + 1,
             parent=node,
-            is_symlink=True,
-            symlink_target=_readlink(link),
-            is_repo=is_repo and not already,
-            is_alias=already,
         )
-        node.children.append(child)
-        if is_repo and not already:
-            _add_submodules(child, target, display, node.depth + 1, visited)
-
-    node.children.sort(key=lambda c: c.name.lower())
+        _record_direct_links(sub, d, display_dir / name, visited)
+        if sub.children:
+            node.children.append(sub)
 
 
 def _add_submodules(
@@ -478,21 +527,16 @@ def _walk(
                 continue
         except OSError:
             continue
+        if link.is_symlink():
+            continue  # symlinks are handled in the second pass
 
-        # Mark every directory we descend into as seen, so no directory is
-        # ever expanded twice — `pulli pull` must not fast-forward the same
-        # work tree from two entries.
+        # Mark every directory we *descend into* as seen — and only those —
+        # so no directory is ever expanded twice: `pulli pull` must not
+        # fast-forward the same work tree from two entries.
         if traverse in visited:
             continue
         visited.add(traverse)
 
-        try:
-            is_dir = link.is_dir()
-        except OSError:
-            continue
-        if not is_dir or link.is_symlink():
-            continue  # symlinks are handled in the second pass
-
         # Guard against permission errors on unreadable dirs.
         try:
             is_repo = _is_git_dir(traverse)

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/pull.py

@@ -31,7 +31,13 @@ import sys
 from pathlib import Path
 
 from .discovery import RepoNode, discover, iter_repos, set_rels
-from .status import collect_status, fetch_all, git_env, run_git
+from .status import (
+    collect_incoming,
+    collect_status,
+    fetch_all,
+    incoming_commits,
+    run_git,
+)
 from .style import BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, Colorizer
 
 _PULL_TIMEOUT = 120
@@ -207,13 +213,7 @@ def pull(
             # fast-forward it is empty).
             new_commits: list[str] = []
             if verbose and node.upstream:
-                rc, out, _ = run_git(
-                    node.path,
-                    "log", "--oneline", f"HEAD..{node.upstream}",
-                    timeout=_PULL_TIMEOUT,
-                )
-                if rc == 0:
-                    new_commits = [l for l in out.splitlines() if l.strip()]
+                new_commits = incoming_commits(node.path, node.upstream)
             rc, stdout, stderr = run_git(
                 node.path, "pull", "--ff-only", "--quiet", timeout=_PULL_TIMEOUT
             )

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/status.py

@@ -351,6 +351,34 @@ def fetch_and_status(
     return failed
 
 
+# ── incoming commits (-v) ───────────────────────────────────────────
+
+_LOG_TIMEOUT = 30
+
+
+def incoming_commits(repo: Path, upstream: str) -> list[str]:
+    """`git log --oneline HEAD..upstream` — the commits a pull would bring
+    in. Must run *before* any pull: after a fast-forward the range is
+    empty. Returns [] on any git failure (stale refs, no upstream object).
+    """
+    rc, out, _ = run_git(repo, "log", "--oneline", f"HEAD..{upstream}",
+                         timeout=_LOG_TIMEOUT)
+    if rc != 0:
+        return []
+    return [l for l in out.splitlines() if l.strip()]
+
+
+def collect_incoming(nodes: list[RepoNode]) -> None:
+    """Fill node.incoming for every repo that is behind its upstream.
+
+    Only repos with something incoming are asked — verbose is an extra git
+    call per *interesting* repo, not per repo in the tree.
+    """
+    for n in nodes:
+        if n.upstream and (n.behind or 0) > 0 and not n.error:
+            n.incoming = incoming_commits(n.path, n.upstream)
+
+
 # ── status collection ────────────────────────────────────────────────────
 
 

{pulli-0.2.13 → pulli-0.2.14}/src/pulli/tree.py

@@ -245,6 +245,7 @@ def _build_lines(
     root: RepoNode,
     C,
     tail,
+    verbose: bool = False,
 ) -> tuple[list[str], dict[int, int], dict[int, str]]:
     """Build the tree lines.
 
@@ -286,6 +287,12 @@ def _build_lines(
             lines.append(base + "  " + tail(node))
             repo_line[id(node)] = len(lines) - 1
             repo_base[id(node)] = base
+            if verbose:
+                # -v: the incoming commits under the repo row, indented like
+                # a child so they read as belonging to it.
+                vp = prefix + ("    " if is_last else "│   ")
+                for c in node.incoming:
+                    lines.append(vp + C(c, DIM))
         elif node.is_bare:
             lines.append(f"{prefix}{connector}{name}/  {C(_BARE_NOTE, DIM)}")
         elif node.is_symlink:
@@ -312,6 +319,7 @@ def _build_flat_lines(
     C,
     tail,
     repos=None,
+    verbose: bool = False,
 ) -> tuple[list[str], dict[int, int], dict[int, str]]:
     """Build a flat list: one line per repo, no tree structure.
 
@@ -353,10 +361,16 @@ def _build_flat_lines(
         lines.append(line)
         repo_line[id(n)] = len(lines) - 1
         repo_base[id(n)] = padded
+        if verbose:
+            # -v: incoming commits, aligned under the status column so they
+            # visually belong to their repo row.
+            indent = " " * (path_width + 2)
+            for c in n.incoming:
+                lines.append(indent + C(c, DIM))
     return lines, repo_line, repo_base
 
 
-def render(root: RepoNode, *, use_color: bool = True) -> str:
+def render(root: RepoNode, *, use_color: bool = True, verbose: bool = False) -> str:
     """Render the full tree as a string."""
 
     def C(s: str, *codes: str) -> str:
@@ -364,11 +378,13 @@ def render(root: RepoNode, *, use_color: bool = True) -> str:
             return s
         return "".join(codes) + s + RESET
 
-    lines, _, _ = _build_lines(root, C, lambda n: _repo_tail(n, C))
+    lines, _, _ = _build_lines(root, C, lambda n: _repo_tail(n, C),
+                               verbose=verbose)
     return "\n".join(lines)
 
 
-def render_flat(root: RepoNode, *, use_color: bool = True, repos=None) -> str:
+def render_flat(root: RepoNode, *, use_color: bool = True, repos=None,
+                verbose: bool = False) -> str:
     """Render a flat list of repos (one line each), not the tree.
 
     `repos` overrides the default "all repos sorted by path" list.
@@ -379,7 +395,8 @@ def render_flat(root: RepoNode, *, use_color: bool = True, repos=None) -> str:
             return s
         return "".join(codes) + s + RESET
 
-    lines, _, _ = _build_flat_lines(root, C, lambda n: _repo_tail(n, C), repos=repos)
+    lines, _, _ = _build_flat_lines(root, C, lambda n: _repo_tail(n, C),
+                                    repos=repos, verbose=verbose)
     return "\n".join(lines)
 
 

{pulli-0.2.13 → pulli-0.2.14}/tests/test_pulli.py

@@ -174,6 +174,65 @@ def test_symlink_does_not_duplicate_a_repo(lab):
     assert "link" not in names      # and the link is not shown as well
 
 
+def test_alias_link_in_recorded_dir_does_not_duplicate_it(lab):
+    """A plain dir the first walk recorded (it holds a repo) must not be
+    duplicated when the link pass finds an alias link in it too — the tree
+    used to show the same directory twice, once per pass."""
+    clones = lab.root / "clones"
+    clones.mkdir()
+    _git(lab.root, "clone", "-q", str(lab.bare), "clones/real")
+    os.symlink(clones / "real", clones / "link")
+    tree = discover(lab.root)
+    set_rels(tree)
+    dup = [c for c in tree.children if c.name == "clones"]
+    assert len(dup) == 1
+    names = {c.name for c in dup[0].children}
+    assert names == {"real", "link"}
+    # and the rendered tree shows the dir once, with both children in it
+    out = render(tree, use_color=False)
+    dir_lines = [l for l in out.splitlines() if l.rstrip().endswith("clones/")]
+    assert len(dir_lines) == 1
+    assert "(alias)" in out
+
+
+def test_links_dir_inside_normally_walked_repo_is_found(lab):
+    """A repo's .links/ dir of sibling links must be found by the normal
+    walk — it used to appear only when the repo itself was reached via a
+    symlink, so the path you took decided what you saw (the a2e3fb9
+    regression)."""
+    outside = lab.root.parent / "elsewhere"
+    outside.mkdir(exist_ok=True)
+    _git(outside, "init", "-q", ".")
+    outer = lab.clone("outer")
+    (outer / ".links").mkdir()
+    os.symlink(outside, outer / ".links" / "sib")
+    tree = discover(lab.root, max_depth=4)
+    set_rels(tree)
+    outer_node = [n for n in iter_repos(tree) if n.name == "outer"][0]
+    links_dir = [c for c in outer_node.children if c.name == ".links"]
+    assert links_dir, "`.links` dir not found under the repo"
+    sib = [c for c in links_dir[0].children if c.name == "sib"]
+    assert sib and sib[0].is_symlink
+    # target is outside the walk — a real repo, not an alias, and pullable
+    assert not sib[0].is_alias
+    assert sib[0].path == outside.resolve()
+    assert any(n.path == outside.resolve() for n in iter_repos(tree))
+
+
+def test_links_dir_descent_respects_max_depth(lab):
+    """The extra .links descent is depth-budgeted like everything else:
+    at max_depth 2 the link (depth 3) stays hidden, at 3 it shows."""
+    outer = lab.clone("outer")
+    (outer / ".links").mkdir()
+    os.symlink(lab.root / "outer", outer / ".links" / "self")
+    shallow = discover(lab.root, max_depth=2)
+    outer_node = [n for n in iter_repos(shallow) if n.name == "outer"][0]
+    assert not [c for c in outer_node.children if c.name == ".links"]
+    deep = discover(lab.root, max_depth=3)
+    outer_node = [n for n in iter_repos(deep) if n.name == "outer"][0]
+    assert [c for c in outer_node.children if c.name == ".links"]
+
+
 def test_no_symlinks_flag_skips_links(lab):
     lab.clone("real")
     os.symlink(lab.root / "real", lab.root / "link")
@@ -775,6 +834,38 @@ def test_cli_attention_filter(lab, capsys):
     assert "current" not in out
 
 
+def test_cli_verbose_lists_incoming_commits(lab, capsys):
+    """tree -v lists the commits a pull would bring in, under the repo
+    row — the flag used to be parsed and then ignored."""
+    r = lab.clone("r")
+    lab.advance_upstream()
+    _git(r, "fetch", "-q")
+    assert cli.main(["-v", "--no-fetch", str(lab.root)]) == 0
+    out = capsys.readouterr().out
+    assert "two" in out          # the upstream commit's message
+    # and only for -v: the plain run stays one line per repo
+    assert cli.main(["--no-fetch", str(lab.root)]) == 0
+    assert "two" not in capsys.readouterr().out
+
+
+def test_pull_verbose_lists_new_commits(lab, capsys):
+    """pull -v shows each pulled repo's new commits (regression for the
+    refactor onto status.incoming_commits)."""
+    import contextlib
+    import io
+
+    r = lab.clone("r")
+    lab.advance_upstream()
+    _git(r, "fetch", "-q")
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        rc = pull(lab.root, fetch=False, verbose=True, use_color=False)
+    assert rc == 0
+    out = buf.getvalue()
+    assert "pulled" in out
+    assert "two" in out          # the commit that just landed
+
+
 def test_cli_filter_empty_says_so(lab, capsys):
     """An empty filter result prints a message, not silence (clig.dev:
     'It's rare that printing nothing at all is the best default')."""
@@ -986,3 +1077,44 @@ def test_update_check_up_to_date(tmp_path, monkeypatch, capsys):
     assert cli.main(["update", "--check"]) == 0
     out = capsys.readouterr().out
     assert "up to date" in out
+
+
+def test_update_falls_through_to_next_installer(tmp_path, monkeypatch, capsys):
+    """A failing uv upgrade must not end the run — pulli may be a pipx
+    install (both land in ~/.local/bin), so pipx gets its turn instead of
+    exiting 1 with the job undone."""
+    from pulli import update
+
+    monkeypatch.setenv("PULLI_CACHE_DIR", str(tmp_path))
+    monkeypatch.setattr(update, "_fetch_latest", lambda: "9.9.9")
+    monkeypatch.setattr(
+        cli.shutil, "which", lambda n: {"uv": "/x/uv", "pipx": "/x/pipx"}[n]
+    )
+
+    tried: list[str] = []
+
+    class _R:
+        def __init__(self, rc: int) -> None:
+            self.returncode = rc
+
+    def fake_run(cmd, *a, **kw):
+        tried.append(cmd[0])
+        return _R(0 if cmd[0] == "pipx" else 1)  # uv fails, pipx wins
+
+    monkeypatch.setattr(cli.subprocess, "run", fake_run)
+    assert cli.main(["update"]) == 0
+    out = capsys.readouterr().out
+    assert tried == ["uv", "pipx"]
+    assert "via pipx" in out
+    assert "Updated" in out
+
+
+def test_update_reports_when_no_installer_succeeds(tmp_path, monkeypatch, capsys):
+    from pulli import update
+
+    monkeypatch.setenv("PULLI_CACHE_DIR", str(tmp_path))
+    monkeypatch.setattr(update, "_fetch_latest", lambda: "9.9.9")
+    monkeypatch.setattr(cli.shutil, "which", lambda n: None)  # nothing on PATH
+    assert cli.main(["update"]) == 1
+    out = capsys.readouterr()
+    assert "no installer succeeded" in out.err