pulli 0.2.9__tar.gz → 0.2.11__tar.gz

{pulli-0.2.9 → pulli-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pulli
-Version: 0.2.9
+Version: 0.2.11
 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.9 → pulli-0.2.11}/src/pulli/__init__.py

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

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/cli.py

@@ -24,6 +24,7 @@ from .discovery import discover, iter_repos, set_rels
 from .pull import pull
 from .status import 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.
@@ -154,6 +155,12 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Omit the one-line summary under the list.",
     )
+    tree_p.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="List the incoming commits under each behind repo "
+        "(git log --oneline, HEAD..upstream).",
+    )
 
     # `pulli pull` — pull repos that are behind.
     pull_p = sub.add_parser("pull", help="Pull repos that are behind upstream.")
@@ -163,6 +170,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Show what would be pulled without pulling.",
     )
+    pull_p.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="List the new commits under each pulled repo (git log --oneline).",
+    )
     pull_p.add_argument(
         "--no-fetch",
         action="store_true",
@@ -308,46 +320,35 @@ def _check_root(root: Path) -> int | None:
 
 
 def _needs_attention(node) -> bool:
-    """A repo the user should look at: broken, busy, diverged, behind, or
-    dirty. Mirrors pull.py's bucket order so tree and pull never disagree
-    about what "needs attention" means."""
-    if node.error or node.operation:
-        return True
-    if node.behind and node.ahead:
-        return True  # diverged
-    if node.behind:
-        return True
-    return bool(node.dirty)
+    """A repo the user should look at — anything that is not CURRENT."""
+    from .state import needs_attention
+    return needs_attention(node)
 
 
 def _summary(repos, use_color: bool) -> str:
     """One line under the list: the answer to "how are my repos doing?",
-    without counting lines by hand. Same buckets as pull.py's summary."""
-    n = len(repos)
-    behind = sum(1 for r in repos if r.behind and not r.ahead)
-    diverged = sum(1 for r in repos if r.behind and r.ahead)
-    ahead = sum(1 for r in repos if r.ahead and not r.behind)
-    dirty = sum(1 for r in repos if r.dirty and not (r.behind or r.ahead))
+    without counting lines by hand. Counts come from the one classifier,
+    so the summary can never disagree with the report or the tree."""
+    from .state import classify
+
+    counts: dict[str, int] = {}
+    for r in repos:
+        counts[classify(r).value] = counts.get(classify(r).value, 0) + 1
     offline = sum(1 for r in repos if r.fetch_failed)
-    broken = sum(1 for r in repos if r.error)
-    parts = [f"{n} repos"]
-    if behind:
-        parts.append(f"{behind} behind")
-    if diverged:
-        parts.append(f"{diverged} diverged")
-    if ahead:
-        parts.append(f"{ahead} ahead")
-    if dirty:
-        parts.append(f"{dirty} dirty")
+    parts = [f"{len(repos)} repos"]
+    for label in ("behind", "diverged", "ahead", "dirty", "broken"):
+        # "behind" in the summary means pullable; pull.py reports the same
+        # repos as "would pull".
+        key = "pullable" if label == "behind" else label
+        if counts.get(key):
+            parts.append(f"{counts[key]} {label}")
     if offline:
         parts.append(f"{offline} offline")
-    if broken:
-        parts.append(f"{broken} broken")
     text = " · ".join(parts)
-    if behind or diverged or broken:
+    if counts.get("pullable") or counts.get("diverged") or counts.get("broken"):
         # Something needs a human — make the line findable at a glance.
-        hint = f"{text} — pulli pull would update {behind} of them"
-        return f"\x1b[1m{hint}\x1b[0m" if use_color else hint
+        hint = f"{text} — pulli pull would update {counts.get('pullable', 0)} of them"
+        return BOLD + hint + RESET if use_color else hint
     return text
 
 
@@ -448,6 +449,7 @@ def _run_pull(args) -> int:
         follow_symlinks=not args.no_symlinks,
         max_depth=args.max_depth,
         link_root=getattr(args, "link_root", None),
+        verbose=getattr(args, "verbose", False),
     )
 
 

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/discovery.py

@@ -52,6 +52,7 @@ class RepoNode:
     untracked_only: bool = False  # dirty, but only untracked files — safe to fast-forward
     upstream: str | None = None
     url: str = ""  # remote url (credentials never stored — scrubbed at render)
+    is_fork: bool = False  # origin is a fork: another remote points at a repo of the same name (likely the upstream parent)
     operation: str | None = None  # "merge in progress", "rebase in progress", …
     fetch_failed: bool = False  # fetch did not succeed (offline / unreachable)
     fetch_reason: str | None = None  # why the fetch failed

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/pull.py

@@ -32,21 +32,13 @@ from pathlib import Path
 
 from .discovery import RepoNode, discover, iter_repos, set_rels
 from .status import collect_status, fetch_all, git_env, run_git
-
-# ANSI colors (mirrors tree.py).
-_RESET = "\x1b[0m"
-_DIM = "\x1b[2m"
-_BOLD = "\x1b[1m"
-_GREEN = "\x1b[32m"
-_YELLOW = "\x1b[33m"
-_RED = "\x1b[31m"
-_CYAN = "\x1b[36m"
+from .style import BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, Colorizer
 
 _PULL_TIMEOUT = 120
 
 
 def _color(s: str, code: str, use_color: bool) -> str:
-    return code + s + _RESET if use_color else s
+    return code + s + RESET if use_color else s
 
 
 def _fmt_ahead_behind(node: RepoNode) -> str:
@@ -68,44 +60,27 @@ def _fmt_dirty(node: RepoNode, use_color: bool) -> str:
     which is what the reader needs to know about them."""
     files = node.dirty_files or []
     if not files:
-        return _color("dirty", _YELLOW, use_color)
+        return _color("dirty", YELLOW, use_color)
     shown = files[:4]
     more = len(files) - len(shown)
     listing = ", ".join(shown) + (f", +{more} more" if more > 0 else "")
     label = "untracked" if node.untracked_only else "dirty"
     return (
-        f"{_color(label, _YELLOW, use_color)} {len(files)} "
-        f"({_color(listing, _DIM, use_color)})"
+        f"{_color(label, YELLOW, use_color)} {len(files)} "
+        f"({_color(listing, DIM, use_color)})"
     )
 
 
 def _classify(node: RepoNode) -> str:
-    """Which bucket a repo falls into. One place, so the report, the
-    counters and the summary can never disagree with each other."""
-    if node.error:
-        return "broken"
-    if node.operation:
-        return "busy"
-    behind, ahead = node.behind or 0, node.ahead or 0
-    if not node.upstream or (not behind and not ahead):
-        return "current"
-    if behind and ahead:
-        return "diverged"
-    if node.dirty and not node.untracked_only:
-        return "dirty"
-    if behind:
-        return "pullable"
-    return "ahead"
+    """Shim over state.classify — kept for _pull_json and the tests."""
+    from .state import classify
+    return classify(node).value
 
 
 def _sort_key(node: RepoNode) -> tuple[int, str]:
-    """Report order: what needs attention first. Tie-break on the display
-    path so two identical runs always print in the same order."""
-    rank = {
-        "broken": 0, "busy": 1, "diverged": 2,
-        "pullable": 3, "dirty": 4, "ahead": 5, "current": 6,
-    }[ _classify(node) ]
-    return (rank, node.rel)
+    """Report order: what needs attention first."""
+    from .state import sort_key
+    return sort_key(node)
 
 
 def _first_meaningful_line(text: str) -> str:
@@ -130,28 +105,28 @@ def _report(node: RepoNode, kind: str, *, use_color: bool, dry_run: bool) -> str
     ab = _fmt_ahead_behind(node)
 
     if kind == "broken":
-        line = f"  {C('✗', _RED, use_color)} {rel}  {C(node.error or 'error', _RED, use_color)}"
+        line = f"  {C('✗', RED, use_color)} {rel}  {C(node.error or 'error', RED, use_color)}"
     elif kind == "busy":
-        line = f"  {C('◐', _YELLOW, use_color)} {rel}  {C(node.operation + ' — skipping pull', _YELLOW, use_color)}"
+        line = f"  {C('◐', YELLOW, use_color)} {rel}  {C(node.operation + ' — skipping pull', YELLOW, use_color)}"
     elif kind == "diverged":
         line = (
-            f"  {C('↕', _YELLOW, use_color)} {rel}  {ab}  "
-            f"{C('diverged — needs merge or rebase, skipping', _YELLOW, use_color)}"
+            f"  {C('↕', YELLOW, use_color)} {rel}  {ab}  "
+            f"{C('diverged — needs merge or rebase, skipping', YELLOW, use_color)}"
         )
     elif kind == "dirty":
         line = (
-            f"  {C('◐', _YELLOW, use_color)} {rel}  {ab}  "
+            f"  {C('◐', YELLOW, use_color)} {rel}  {ab}  "
             f"{_fmt_dirty(node, use_color)}, skipping pull — "
-            f"{C('commit or stash, then pulli pull again', _DIM, use_color)}"
+            f"{C('commit or stash, then pulli pull again', DIM, use_color)}"
         )
     elif kind == "ahead":
-        line = f"  {C('↑', _CYAN, use_color)} {rel}  {C(f'↑{node.ahead} ahead (not pushed)', _CYAN, use_color)}"
+        line = f"  {C('↑', CYAN, use_color)} {rel}  {C(f'↑{node.ahead} ahead (not pushed)', CYAN, use_color)}"
     elif kind == "current":
         # Nothing to do. A dirty repo with nothing to pull is only worth
         # mentioning in dry-run mode, where the point is a full inventory.
         if not (dry_run and node.dirty):
             return None
-        line = f"  {C('◐', _YELLOW, use_color)} {rel}  up to date  {_fmt_dirty(node, use_color)}"
+        line = f"  {C('◐', YELLOW, use_color)} {rel}  up to date  {_fmt_dirty(node, use_color)}"
     else:  # pullable
         return None  # printed by the pull loop, which knows the outcome
     print(line)
@@ -167,6 +142,7 @@ def pull(
     follow_symlinks: bool = True,
     max_depth: int = 50,
     link_root: Path | None = None,
+    verbose: bool = False,
 ) -> int:
     """Pull every repo under `root` that is behind upstream.
 
@@ -215,17 +191,29 @@ def pull(
 
     if dry_run:
         print()
-        print(_color("Dry run — no pulls performed.", _BOLD, use_color))
+        print(_color("Dry run — no pulls performed.", BOLD, use_color))
         for node in pullable:
             note = ""
             if node.dirty and node.untracked_only:
-                note = _color("  (untracked files only — safe)", _DIM, use_color)
+                note = _color("  (untracked files only — safe)", DIM, use_color)
             print(
-                f"  {_color('↓', _GREEN, use_color)} {node.rel}  "
-                f"{_fmt_ahead_behind(node)}  {_color('would pull', _GREEN, use_color)}{note}"
+                f"  {_color('↓', GREEN, use_color)} {node.rel}  "
+                f"{_fmt_ahead_behind(node)}  {_color('would pull', GREEN, use_color)}{note}"
             )
     else:
         for node in pullable:
+            # The commits this pull will bring in — captured *before* the
+            # pull, while the range HEAD..upstream still exists (after a
+            # 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()]
             rc, stdout, stderr = run_git(
                 node.path, "pull", "--ff-only", "--quiet", timeout=_PULL_TIMEOUT
             )
@@ -233,18 +221,20 @@ def pull(
                 pulled.append(node)
                 note = ""
                 if node.dirty and node.untracked_only:
-                    note = _color("  (untracked files kept)", _DIM, use_color)
+                    note = _color("  (untracked files kept)", DIM, use_color)
                 print(
-                    f"  {_color('✓', _GREEN, use_color)} {node.rel}  "
+                    f"  {_color('✓', GREEN, use_color)} {node.rel}  "
                     f"{_fmt_ahead_behind(node)}  pulled{note}"
                 )
+                for c in new_commits:
+                    print(_color(f"      {c}", DIM, use_color))
             else:
                 reason = _first_meaningful_line(stderr or stdout) or f"exit {rc}"
                 failed.append((node, reason))
                 print(
-                    f"  {_color('✗', _RED, use_color)} {node.rel}  "
+                    f"  {_color('✗', RED, use_color)} {node.rel}  "
                     f"{_fmt_ahead_behind(node)}  "
-                    f"{_color('pull failed: ' + reason, _RED, use_color)}"
+                    f"{_color('pull failed: ' + reason, RED, use_color)}"
                 )
 
     # ── summary ──────────────────────────────────────────────────────────
@@ -257,7 +247,7 @@ def pull(
             _color(
                 f"note: {len(offline)} repo(s) unreachable — their ↓↑ may be "
                 "stale (rerun when online).",
-                _YELLOW,
+                YELLOW,
                 use_color,
             )
         )

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/spinner.py

@@ -24,11 +24,8 @@ _INTERVAL = 0.08
 # wipe it completely when we're done so it never trails into real output.
 _CLEAR = "\r\x1b[2K"
 
-# ANSI colors, matching pulli's palette (tree.py / pull.py). The glyph is
-# cyan (accent-ish), the message is dim (muted) — like pi's loader.
-_CYAN = "\x1b[36m"
-_DIM = "\x1b[2m"
-_RESET = "\x1b[0m"
+# The palette lives in style.py; the spinner only picks two entries.
+from .style import CYAN, DIM, RESET
 
 
 class Spinner:
@@ -77,7 +74,7 @@ class Spinner:
         self._frame += 1
         with self._write_lock:
             if self.use_color:
-                self.stream.write(f"\r{_CYAN}{frame}{_RESET} {_DIM}{self.message}{_RESET}")
+                self.stream.write(f"\r{CYAN}{frame}{RESET} {DIM}{self.message}{RESET}")
             else:
                 self.stream.write(f"\r{frame} {self.message}")
             self.stream.flush()

pulli-0.2.11/src/pulli/state.py

@@ -0,0 +1,116 @@
+"""RepoState — one classifier, one precedence, every consumer a lookup.
+
+"What state is this repo in?" used to be decided five times (pull's
+_classify, cli's _needs_attention, tree's _line_color and _status_glyph,
+cli's _summary counts), each with its own subtly different precedence —
+and tree and pull could genuinely disagree about the same repo.
+
+Now there is one precedence table, and it is pull.py's (the safety-
+relevant one): a repo is classified by the first rule that matches.
+
+    error        → BROKEN        report, skip, exit non-zero
+    operation    → BUSY          report, skip
+    diverged     → DIVERGED      report, skip (ff impossible)
+    dirty-tracked→ DIRTY         report, skip (commit or stash first)
+    behind       → PULLABLE      git pull --ff-only
+                   (untracked-only dirty does not block a pull)
+    ahead        → AHEAD         note: push when you like
+    otherwise    → CURRENT       silent
+
+Every derived view — glyph, line color, attention filter, report bucket,
+summary count — is a lookup on this enum, so the views can no longer
+disagree with each other or with what pull actually does.
+"""
+from __future__ import annotations
+
+from enum import Enum
+
+from .discovery import RepoNode
+from .style import CYAN, GREEN, RED, YELLOW
+
+
+class RepoState(Enum):
+    BROKEN = "broken"          # git itself failed on this repo
+    BUSY = "busy"              # merge/rebase/bisect in progress
+    DIVERGED = "diverged"      # ahead *and* behind — ff impossible
+    DIRTY = "dirty"            # tracked changes — pull would clobber
+    PULLABLE = "pullable"      # behind only — git pull --ff-only
+    AHEAD = "ahead"            # commits not pushed
+    CURRENT = "current"        # nothing to do
+
+
+def classify(node: RepoNode) -> RepoState:
+    """The one precedence table. First match wins."""
+    if node.error:
+        return RepoState.BROKEN
+    if node.operation:
+        return RepoState.BUSY
+    behind, ahead = node.behind or 0, node.ahead or 0
+    if behind and ahead:
+        return RepoState.DIVERGED
+    if node.dirty and not node.untracked_only:
+        return RepoState.DIRTY
+    if behind:
+        return RepoState.PULLABLE
+    if ahead:
+        return RepoState.AHEAD
+    return RepoState.CURRENT
+
+
+# ── derived views: lookups, not logic ────────────────────────────────────
+
+#: Glyph shown in the tree's state column.
+_GLYPHS: dict[RepoState, tuple[str, str]] = {
+    RepoState.BROKEN: ("✗", RED),
+    RepoState.BUSY: ("◐", YELLOW),
+    RepoState.DIVERGED: ("◐", YELLOW),
+    RepoState.DIRTY: ("◐", YELLOW),
+    RepoState.PULLABLE: ("●", GREEN),
+    RepoState.AHEAD: ("●", GREEN),
+    RepoState.CURRENT: ("●", GREEN),
+}
+
+
+def glyph(node: RepoNode) -> tuple[str, str]:
+    """(symbol, color) for the state column."""
+    return _GLYPHS[classify(node)]
+
+
+#: Whole-line highlight color for actionable rows, None for quiet rows.
+#: Behind (pull me) and dirty-tracked (commit/stash me) are the two
+#: states that ask for action; the eye scans rows before columns.
+_LINE_COLORS: dict[RepoState, str | None] = {
+    RepoState.BROKEN: None,
+    RepoState.BUSY: None,
+    RepoState.DIVERGED: None,
+    RepoState.DIRTY: YELLOW,
+    RepoState.PULLABLE: CYAN,
+    RepoState.AHEAD: None,
+    RepoState.CURRENT: None,
+}
+
+
+def line_color(node: RepoNode) -> str | None:
+    """Whole-line highlight color, or None for a quiet row."""
+    return _LINE_COLORS[classify(node)]
+
+
+def needs_attention(node: RepoNode) -> bool:
+    """A repo the user should look at: anything that is not CURRENT."""
+    return classify(node) is not RepoState.CURRENT
+
+
+#: Report order: what needs attention first. Tie-break on display path.
+_RANKS: dict[RepoState, int] = {
+    RepoState.BROKEN: 0,
+    RepoState.BUSY: 1,
+    RepoState.DIVERGED: 2,
+    RepoState.PULLABLE: 3,
+    RepoState.DIRTY: 4,
+    RepoState.AHEAD: 5,
+    RepoState.CURRENT: 6,
+}
+
+
+def sort_key(node: RepoNode) -> tuple[int, str]:
+    return (_RANKS[classify(node)], node.rel)

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/status.py

@@ -154,6 +154,55 @@ def _remote_url(repo: Path, env: dict[str, str] | None = None) -> str:
     return ""
 
 
+def _is_fork(repo: Path, env: dict[str, str] | None = None) -> bool:
+    """True when the repo looks like a fork.
+
+    Two signals, either one is enough:
+      1. a remote named `upstream` — the documented GitHub convention for
+         "the repo I forked from";
+      2. remotes pointing at the same repo *name* under different *owners*
+         (`devskale/rodney` + `simonw/rodney`), compared case-insensitively.
+
+    Name comparison alone misses forks whose copy was renamed
+    (`devskale/handyST` forked from `cjpais/Handy`) — hence signal 1.
+    """
+    remotes = _git_one(repo, "remote", env=env).split()
+    if len(remotes) < 2:
+        return False
+    if "upstream" in remotes:
+        return True
+    owners: set[str] = set()
+    names: set[str] = set()
+    for name in remotes:
+        url = _git_one(repo, "remote", "get-url", name, env=env)
+        owner, rname = _owner_repo(url)
+        if rname:
+            owners.add(owner.lower())
+            names.add(rname.lower())
+    # same repo name under more than one owner = a fork and its parent
+    return len(names) == 1 and len(owners) >= 2
+
+
+def _owner_repo(url: str) -> tuple[str, str]:
+    """(owner, repo) from a remote url; ('', '') when unparseable.
+
+    `git@h:owner/repo.git` and `https://h/owner/repo` -> ('owner', 'repo').
+    """
+    if not url:
+        return "", ""
+    if "://" in url:
+        url = url.split("://", 1)[1]
+    if ":" in url:  # scp-like git@host:owner/repo
+        url = url.split(":", 1)[1]
+    parts = [p for p in url.split("/") if p]
+    if len(parts) < 2:
+        return "", ""
+    repo = parts[-1]
+    if repo.endswith(".git"):
+        repo = repo[: -len(".git")]
+    return parts[-2], repo
+
+
 # ── fetch ────────────────────────────────────────────────────────────────
 
 
@@ -351,6 +400,7 @@ def _collect_one_locked(node: RepoNode, repo: Path, env: dict[str, str]) -> None
         return
 
     node.url = _remote_url(repo, env)
+    node.is_fork = _is_fork(repo, env)
 
     # Branch / ref name. HEAD may be detached.
     branch = _git_one(repo, "symbolic-ref", "--quiet", "--short", "HEAD", env=env)

pulli-0.2.11/src/pulli/style.py

@@ -0,0 +1,93 @@
+"""ANSI styling — one palette, one gate, one place.
+
+Every visual decision in pulli goes through this module: the palette
+constants, the should-this-be-colored gate (TTY, --no-color, NO_COLOR,
+TERM=dumb), and the whole-line highlight that survives nested SGR resets.
+
+Before this module existed the palette was defined four times (tree.py,
+pull.py, spinner.py, cli.py) with three different helper shapes, and the
+NO_COLOR gate only lived in cli.py — so any new consumer could (and did)
+forget it. Now the gate is part of the interface: a Colorizer is either
+on or off, and everything rendered through it honors the same rules.
+"""
+from __future__ import annotations
+
+import re
+import sys
+
+# ── palette ──────────────────────────────────────────────────────────────
+
+RESET = "\x1b[0m"
+DIM = "\x1b[2m"
+BOLD = "\x1b[1m"
+GREEN = "\x1b[32m"
+YELLOW = "\x1b[33m"
+RED = "\x1b[31m"
+CYAN = "\x1b[36m"
+MAGENTA = "\x1b[35m"
+
+# 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 should_color(stream=None, *, override: bool | None = None) -> bool:
+    """The one color gate: TTY + no NO_COLOR + not TERM=dumb.
+
+    `override` is the --no-color / forced-color decision from the CLI and
+    wins over everything. Kept separate from the Colorizer so callers can
+    ask "would color be on?" without constructing one.
+    """
+    if override is False:
+        return False
+    stream = stream if stream is not None else sys.stdout
+    try:
+        if not stream.isatty():
+            return False
+    except (AttributeError, OSError):
+        return False
+    # no-color.org convention: NO_COLOR set to any non-empty value.
+    import os
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("TERM") == "dumb":
+        return False
+    return True
+
+
+class Colorizer:
+    """Wrap text in ANSI codes — or don't, when color is off.
+
+    One callable: `C(text, *codes)`. When disabled it is the identity,
+    so render code has no `if use_color` branches — it always calls C.
+    """
+
+    def __init__(self, enabled: bool) -> None:
+        self.enabled = enabled
+
+    def __call__(self, s: str, *codes: str) -> str:
+        if not self.enabled or not codes:
+            return s
+        return "".join(codes) + s + RESET
+
+
+def highlight_line(line: str, color: str) -> str:
+    """Color-wrap a whole line, surviving nested SGR resets.
+
+    Inner resets (e.g. the count's own cyan+bold) would end the outer
+    color mid-line and make the line render two-tone; re-apply the color
+    after each reset so the line stays one color throughout.
+    Returns the input unchanged when it carries no ANSI codes (color off)
+    — nothing to highlight then.
+    """
+    if "\x1b[" not in line:
+        return line
+    # Drop dim segments: dim-color renders darker than the color, which
+    # would split the highlighted line into bright and dark halves. The
+    # point of the highlight is one uniform color.
+    line = line.replace(DIM, "")
+    return color + line.replace(RESET, RESET + color) + RESET

{pulli-0.2.9 → pulli-0.2.11}/src/pulli/tree.py

@@ -37,32 +37,31 @@ 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"
+from .style import (
+    BOLD,
+    CYAN,
+    DIM,
+    GREEN,
+    MAGENTA,
+    RED,
+    RESET,
+    YELLOW,
+    Colorizer,
+    highlight_line,
+    visible_width,
+)
 
 _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))
+    return visible_width(s)
 
 
 def _clip_ansi(s: str, width: int) -> str:
@@ -105,7 +104,7 @@ def _clip_ansi(s: str, width: int) -> str:
             vis += 1
             i += 1
     if truncated:
-        out.append(_RESET)
+        out.append(RESET)
     return "".join(out)
 
 
@@ -145,12 +144,9 @@ def _shorten_url(url: str) -> str:
 
 
 def _status_glyph(node: RepoNode) -> tuple[str, str]:
-    """Return (glyph, color) for the ok/dirty/error state."""
-    if node.error:
-        return "✗", _RED
-    if node.dirty or node.operation:
-        return "◐", _YELLOW
-    return "●", _GREEN
+    """(symbol, color) for the state column."""
+    from .state import glyph
+    return glyph(node)
 
 
 def _ahead_behind(node: RepoNode, C=lambda s, *c: s) -> str:
@@ -166,23 +162,19 @@ def _ahead_behind(node: RepoNode, C=lambda s, *c: s) -> str:
     if not node.upstream:
         return "·  ·"
     behind, ahead = node.behind or 0, node.ahead or 0
-    b = C(f"↓{behind}", _CYAN, _BOLD) if behind else f"↓{behind}"
-    a = C(f"↑{ahead}", _CYAN, _BOLD) if ahead else f"↑{ahead}"
+    b = C(f"↓{behind}", CYAN, BOLD) if behind else f"↓{behind}"
+    a = C(f"↑{ahead}", CYAN, BOLD) if ahead else f"↑{ahead}"
     return f"{b} {a}"
 
 
-def _highlight_line(line: str) -> str:
-    """Cyan-wrap a whole line, surviving nested SGR resets.
+def _highlight_line(line: str, color: str = CYAN) -> str:
+    return highlight_line(line, color)
 
-    Inner resets (e.g. the count's own cyan+bold) would end the outer cyan
-    mid-line and make the line render two-tone; re-apply the cyan after
-    each reset so the line stays one color throughout. Returns the input
-    unchanged when it carries no ANSI codes (color off) — nothing to
-    highlight then.
-    """
-    if "\x1b[" not in line:
-        return line
-    return _CYAN + line.replace(_RESET, _RESET + _CYAN) + _RESET
+
+def _line_color(node: RepoNode) -> str | None:
+    """Whole-line highlight color for a repo, or None."""
+    from .state import line_color
+    return line_color(node)
 
 
 def _repo_tail_parts(node: RepoNode, C) -> list[str]:
@@ -193,20 +185,25 @@ def _repo_tail_parts(node: RepoNode, C) -> list[str]:
     joins them with two spaces.
     """
     if node.error:
-        return [C(f"✗ {node.error}", _RED)]
+        return [C(f"✗ {node.error}", RED)]
 
     url = _shorten_url(node.url)
     parts = [
-        C(url, _DIM) if url else "",
-        C(node.branch or "?", _BOLD),
+        C(url, DIM) if url else "",
+        C(node.branch or "?", BOLD),
         _ahead_behind(node, C),
     ]
+    if node.is_fork:
+        # A fork pulls from its own copy but usually wants to track the
+        # parent — worth a marker so "behind 0" is not read as "caught up
+        # with the parent" when it only means "caught up with my fork".
+        parts.append(C("⑂ fork", MAGENTA))
 
     if node.operation:
-        state = C(f"◐ {node.operation} — skipping", _YELLOW)
+        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)
+        state = C(f"◐ offline — {node.fetch_reason or 'unreachable'}", YELLOW)
     else:
         glyph, gcolor = _status_glyph(node)
         if node.dirty:
@@ -215,9 +212,9 @@ def _repo_tail_parts(node: RepoNode, C) -> list[str]:
             # pull can't conflict with an untracked file. So it gets its own
             # word and a softer color than tracked changes, which can.
             if node.untracked_only:
-                state = C(f"◐ untracked {len(node.dirty_files)}", _DIM)
+                state = C(f"◐ untracked {len(node.dirty_files)}", DIM)
             else:
-                state = C(f"◐ dirty {len(node.dirty_files)}", _YELLOW)
+                state = C(f"◐ dirty {len(node.dirty_files)}", YELLOW)
         else:
             state = C(glyph, gcolor)
 
@@ -233,14 +230,14 @@ def _repo_tail(node: RepoNode, C) -> str:
 def _label(node: RepoNode, C) -> str:
     name = node.name
     if node.is_submodule:
-        return C(name, _CYAN) + C(" (submodule)", _DIM)
+        return C(name, CYAN) + C(" (submodule)", DIM)
     if node.is_symlink:
-        s = C(name, _MAGENTA) + C(" -> " + (node.symlink_target or ""), _DIM)
+        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 s + (C(" (alias)", DIM) if node.is_alias else C(" (symlink)", DIM))
     return name
 
 
@@ -265,14 +262,14 @@ def _build_lines(
 
     # 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)
+    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)
+        header += "  " + C(_BARE_NOTE, DIM)
     lines.append(header)
 
     def render_node(node: RepoNode, prefix: str, is_last: bool) -> None:
@@ -290,14 +287,14 @@ def _build_lines(
             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)}")
+            lines.append(f"{prefix}{connector}{name}/  {C(_BARE_NOTE, DIM)}")
         elif node.is_symlink:
             # A link to a plain dir: the label already carries the marker,
             # and a trailing / would land *after* it — "(symlink)/".
             lines.append(f"{prefix}{connector}{name}")
         else:
             # plain directory — show with trailing /, no status
-            lines.append(f"{prefix}{connector}{C(name + '/', _DIM)}")
+            lines.append(f"{prefix}{connector}{C(name + '/', DIM)}")
 
         child_prefix = prefix + ("    " if is_last else "│   ")
         for i, child in enumerate(node.children):
@@ -333,11 +330,11 @@ def _build_flat_lines(
         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)
+    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)
+        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
@@ -347,11 +344,12 @@ def _build_flat_lines(
             cols[0] = cols[0] + " " * (url_width - _visible_width(cols[0]))
         text = "  ".join(c for c in cols if c)
         line = padded + "  " + text
-        # A repo that is behind is the actionable one — `pulli pull` acts on
-        # it — so the whole line is highlighted (cyan) instead of just the
-        # count. Everything up to date stays quiet: no news takes no color.
-        if n.behind and not n.error:
-            line = _highlight_line(line)
+        # Actionable rows get the whole line (see _line_color): behind →
+        # cyan (pull), dirty tracked changes → yellow (commit/stash).
+        # Everything else stays quiet: no news takes no color.
+        color = _line_color(n)
+        if color:
+            line = _highlight_line(line, color)
         lines.append(line)
         repo_line[id(n)] = len(lines) - 1
         repo_base[id(n)] = padded
@@ -364,7 +362,7 @@ def render(root: RepoNode, *, use_color: bool = True) -> str:
     def C(s: str, *codes: str) -> str:
         if not use_color:
             return s
-        return "".join(codes) + s + _RESET
+        return "".join(codes) + s + RESET
 
     lines, _, _ = _build_lines(root, C, lambda n: _repo_tail(n, C))
     return "\n".join(lines)
@@ -379,7 +377,7 @@ def render_flat(root: RepoNode, *, use_color: bool = True, repos=None) -> str:
     def C(s: str, *codes: str) -> str:
         if not use_color:
             return s
-        return "".join(codes) + s + _RESET
+        return "".join(codes) + s + RESET
 
     lines, _, _ = _build_flat_lines(root, C, lambda n: _repo_tail(n, C), repos=repos)
     return "\n".join(lines)
@@ -412,7 +410,7 @@ class LiveTree:
         def C(s: str, *codes: str) -> str:
             if not use_color:
                 return s
-            return "".join(codes) + s + _RESET
+            return "".join(codes) + s + RESET
 
         self._C = C
         self._flat = flat
@@ -430,7 +428,7 @@ class LiveTree:
             # 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))
+            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
@@ -439,7 +437,7 @@ class LiveTree:
             return
 
         self._active = True
-        lines, repo_line, repo_base = builder(root, C, lambda n: C("…", _DIM))
+        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
@@ -476,10 +474,11 @@ class LiveTree:
         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)
-        # Same highlight rule as _build_flat_lines: the whole line goes
-        # cyan when the repo is behind — that is the actionable state.
-        if self._flat and node.behind and not node.error:
-            text = _highlight_line(text)
+        # Same highlight rule as _build_flat_lines (see _line_color).
+        if self._flat:
+            color = _line_color(node)
+            if color:
+                text = _highlight_line(text, color)
         text = _clip_ansi(text, self._width)
         with self._lock:
             self._rewrite(i, text)

{pulli-0.2.9 → pulli-0.2.11}/tests/test_pulli.py

@@ -526,6 +526,25 @@ def test_render_untracked_only_is_not_dirty(lab):
     assert "dirty" not in out
 
 
+def test_fork_marker(lab):
+    """A repo whose remotes point at the same name under different owners
+    is a fork and gets the ⑂ marker; a plain two-remote repo does not."""
+    # The lab clone's origin is <root>/origin.git -> repo name 'origin'.
+    r = lab.clone("rodney")
+    _git(r, "remote", "set-url", "origin", "https://github.com/simonw/rodney.git")
+    _git(r, "remote", "add", "fork", "https://github.com/devskale/rodney.git")
+    plain = lab.clone("plain")
+    _git(plain, "remote", "set-url", "origin", "https://github.com/simonw/rodney.git")
+    _git(plain, "remote", "add", "other", "https://github.com/devskale/other-repo.git")
+    tree = discover(lab.root)
+    set_rels(tree)
+    collect_status(tree)
+    out = render_flat(tree, use_color=False)
+    assert "⑂ fork" in out
+    assert out.count("⑂") == 1
+    assert "other-repo" not in out
+
+
 def test_no_upstream_renders_placeholder(lab):
     r = lab.clone("r")
     _git(r, "remote", "remove", "origin")