gitpulse-tui 1.2.4__tar.gz → 1.2.6__tar.gz

{gitpulse_tui-1.2.4/gitpulse_tui.egg-info → gitpulse_tui-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpulse-tui
-Version: 1.2.4
+Version: 1.2.6
 Summary: Git Repo Dashboard TUI — live status, commits, diffs, and branches in your terminal
 Requires-Python: >=3.10
 License-File: LICENSE

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/README.md

@@ -47,9 +47,9 @@ source ~/.zshrc   # or source ~/.bashrc
 ## Usage
 
 ```bash
-gitpulse                          # scans ~/projects (default)
+gitpulse                          # scans current directory (or scan.roots from config)
 gitpulse --root /path/to/repos   # scans a custom directory
-gitpulse --root .                 # scans current directory
+gitpulse --root .                 # scans current directory explicitly
 gitpulse --commits 20            # show 20 commits per repo (default: 10)
 gitpulse --version               # print version
 ```

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/digest.py

@@ -77,12 +77,13 @@ def _collect_for_repo(
     if not all_commits:
         return None
 
-    # De-duplicate by hash in case multiple patterns matched same commit
+    # De-duplicate by full hash (not short hash, which can collide in large repos)
     seen: set[str] = set()
     unique: list[AuthorCommit] = []
     for c in all_commits:
-        if c.short_hash not in seen:
-            seen.add(c.short_hash)
+        key = c.full_hash or c.short_hash  # full_hash preferred
+        if key not in seen:
+            seen.add(key)
             unique.append(c)
 
     unique.sort(key=lambda c: c.ts, reverse=True)

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/git_ops.py

@@ -82,6 +82,7 @@ class AuthorCommit:
     insertions: int = 0
     deletions: int = 0
     files_changed: int = 0
+    full_hash: str = ""  # full 40-char SHA used for deduplication
 
 
 @dataclass
@@ -201,14 +202,23 @@ def get_repo_info(path: Path) -> RepoInfo:
             except Exception:
                 contributor_count = 0
 
-            # Commit activity: commits per week for the last 7 weeks (sparkline buckets)
+            # Commit activity: commits per week for the last 7 weeks (sparkline).
+            # Use a fast plumbing command (timestamps only) instead of loading
+            # full commit objects, which is ~10x faster on large repos.
             try:
                 now_ts = time.time()
-                for c in repo.iter_commits(max_count=200):
-                    age_days = (now_ts - float(c.committed_date)) / 86400
-                    week_idx = int(age_days // 7)
-                    if 0 <= week_idx < 7:
-                        activity[week_idx] += 1
+                cutoff = int(now_ts - 7 * 7 * 86400)
+                log_out = repo.git.log(
+                    "--format=%ct", f"--after={cutoff}", "HEAD",
+                )
+                for ts_str in log_out.splitlines():
+                    try:
+                        age_days = (now_ts - float(ts_str.strip())) / 86400
+                        week_idx = int(age_days // 7)
+                        if 0 <= week_idx < 7:
+                            activity[week_idx] += 1
+                    except ValueError:
+                        pass
                 activity.reverse()  # oldest week first
             except Exception:
                 activity = [0] * 7
@@ -257,7 +267,7 @@ def get_repo_info(path: Path) -> RepoInfo:
         except Exception:
             pass
 
-    except (InvalidGitRepositoryError, Exception):
+    except Exception:  # InvalidGitRepositoryError, PermissionError, etc.
         branch = "unknown"
         status = RepoStatus.CLEAN
         mod_count = 0
@@ -355,18 +365,20 @@ def get_commits(path: Path, n: int = 10) -> list[CommitInfo]:
 
 def get_diff(path: Path) -> str:
     """
-    Return the uncommitted diff (working tree vs index) as a string.
+    Return the uncommitted diff as a string.
+
+    Combines staged (cached) and unstaged changes so both are visible when
+    a file has entries in both states.  Staged changes are shown first.
     """
     repo = _open_repo(path)
 
     try:
-        diff_text = repo.git.diff()
-        if not diff_text:
-            staged_diff = repo.git.diff("--cached")
-            if staged_diff:
-                return staged_diff
+        staged_diff = repo.git.diff("--cached")
+        unstaged_diff = repo.git.diff()
+        parts = [p for p in (staged_diff, unstaged_diff) if p]
+        if not parts:
             return "No uncommitted changes."
-        return diff_text
+        return "\n".join(parts)
     except Exception as exc:
         return f"Error getting diff: {exc}"
 
@@ -471,40 +483,40 @@ def get_tags(path: Path, n: int = 15) -> list[TagInfo]:
     Return the most recent `n` tags, sorted by date descending.
     """
     repo = _open_repo(path)
-    tags: list[TagInfo] = []
+    # Store (timestamp, TagInfo) so we sort by the raw float, not the
+    # formatted string (which would put empty-date error entries at the top).
+    tagged: list[tuple[float, TagInfo]] = []
 
     try:
         for tag_ref in repo.tags:
             try:
-                # Annotated tag
                 tag_obj = tag_ref.tag
                 if tag_obj:
-                    ts = tag_obj.tagged_date
+                    ts = float(tag_obj.tagged_date)
                     date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
                     message = (tag_obj.message or "").strip().split("\n")[0]
                     tagger = str(tag_obj.tagger) if tag_obj.tagger else ""
                 else:
                     # Lightweight tag — use commit date
                     commit = tag_ref.commit
-                    ts = commit.committed_date
+                    ts = float(commit.committed_date)
                     date_str = datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
                     message = commit.message.strip().split("\n")[0]
                     tagger = str(commit.author)
 
-                tags.append(TagInfo(
+                tagged.append((ts, TagInfo(
                     name=tag_ref.name,
                     date=date_str,
                     message=message,
                     tagger=tagger,
-                ))
+                )))
             except Exception:
-                tags.append(TagInfo(name=tag_ref.name, date="", message="", tagger=""))
+                tagged.append((0.0, TagInfo(name=tag_ref.name, date="", message="", tagger="")))
     except Exception:
         pass
 
-    # Sort by date descending, take first n
-    tags.sort(key=lambda t: t.date, reverse=True)
-    return tags[:n]
+    tagged.sort(key=lambda x: x[0], reverse=True)
+    return [t for _, t in tagged[:n]]
 
 
 def stage_files(path: Path, files: list[str]) -> str:
@@ -562,11 +574,13 @@ def commit_changes(path: Path, message: str) -> str:
     try:
         if not message.strip():
             return "Error: commit message cannot be empty"
-        # Check there is something staged
+        # Check there is something staged.
+        # On a repo with no commits yet, diff("HEAD") raises — fall back to
+        # checking the raw index entries so the very first commit is not blocked.
         try:
             staged = list(repo.index.diff("HEAD"))
         except Exception:
-            staged = []
+            staged = list(repo.index.entries.keys())
         if not staged:
             return "Nothing staged to commit. Stage files first."
         commit_obj = repo.index.commit(message.strip())
@@ -1049,6 +1063,7 @@ def get_author_commits(
 
             commits.append(AuthorCommit(
                 short_hash=full_hash[:7],
+                full_hash=full_hash,
                 ts=ts,
                 message=subject.strip(),
                 insertions=insertions,

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/main.py

@@ -97,7 +97,8 @@ class GitPulseApp(App):
         self._scanning = False          # Guard against concurrent scans
         self._watch_enabled = watch     # Whether watch mode is on
         self._watch_paused = False      # Toggled by 'w' key
-        self._signatures: dict = {}     # path → (HEAD mtime, index mtime, refs mtime)
+        self._signatures: dict = {}     # path → (HEAD mtime, index mtime, refs mtime, packed-refs mtime)
+        self._fleet_category: str = ""  # Active fleet-filter category ("" = none)
 
     # -----------------------------------------------------------------
     # Layout
@@ -195,8 +196,12 @@ class GitPulseApp(App):
 
     def _dispatch_bulk(self, action_key: str, repos: list) -> None:
         """Fan out a bulk git operation over repos using a thread pool worker."""
-        from gitpulse.git_ops import git_fetch, git_pull, git_push, git_gc, git_remote_prune, git_clean_dry, get_repo_info
-        from gitpulse.parallel import run_parallel
+        try:
+            from gitpulse.git_ops import git_fetch, git_pull, git_push, git_gc, git_remote_prune, git_clean_dry, get_repo_info
+            from gitpulse.parallel import run_parallel
+        except ImportError:
+            from git_ops import git_fetch, git_pull, git_push, git_gc, git_remote_prune, git_clean_dry, get_repo_info  # type: ignore[no-redef]
+            from parallel import run_parallel  # type: ignore[no-redef]
 
         _ops = {
             "fetch":   lambda r: git_fetch(r.path),
@@ -287,6 +292,18 @@ class GitPulseApp(App):
                 self._refresh_single_repo(updated)
                 return
 
+            if group == "branch_switch":
+                # Result is (switch_message, updated_RepoInfo)
+                switch_msg, updated_info = event.worker.result
+                self.notify(switch_msg, timeout=3)
+                self._refresh_single_repo(updated_info)
+                self._start_scan()
+                return
+
+            if group not in (None, "scan"):
+                # Unknown group (e.g. git_op owned by MainPanel) — ignore here.
+                return
+
             # Full scan result
             self._scanning = False
             infos: list[RepoInfo] = event.worker.result
@@ -366,20 +383,18 @@ class GitPulseApp(App):
         main.load_repo(repo_info.path, repo_info)
 
     def _apply_filter(self, query: str) -> None:
-        """Filter the repo list by name, re-populate sidebar."""
+        """Filter the repo list by name, preserving any active fleet filter."""
         q = query.strip().lower()
-        if q:
-            self.repos = [r for r in self._all_repos if q in r.name.lower()]
-        else:
-            self.repos = list(self._all_repos)
+        base = self._fleet_filtered_repos()
+        self.repos = [r for r in base if q in r.name.lower()] if q else list(base)
 
         sidebar: RepoSidebar = self.query_one("#sidebar-container", RepoSidebar)
         sidebar.populate(self.repos)
         if self.repos:
             self._select_repo(self.repos[0])
 
-    def _apply_fleet_filter(self, category: str) -> None:
-        """Filter sidebar to repos matching a fleet-status category."""
+    def _fleet_filtered_repos(self) -> list[RepoInfo]:
+        """Return _all_repos filtered by the current fleet category (if any)."""
         from gitpulse.git_ops import RepoStatus  # avoid circular at module level
         _predicates = {
             "dirty":   lambda r: r.status != RepoStatus.CLEAN,
@@ -388,15 +403,22 @@ class GitPulseApp(App):
             "stashes": lambda r: r.stash_count > 0,
             "stale":   lambda r: r.has_stale_branches,
         }
-        pred = _predicates.get(category)
+        pred = _predicates.get(self._fleet_category)
         if pred is None:
-            self.repos = list(self._all_repos)
-        else:
-            self.repos = [r for r in self._all_repos if pred(r)]
+            return list(self._all_repos)
+        return [r for r in self._all_repos if pred(r)]
+
+    def _apply_fleet_filter(self, category: str) -> None:
+        """Filter sidebar to repos matching a fleet-status category and highlight chip."""
+        self._fleet_category = category
+        self.repos = self._fleet_filtered_repos()
 
         sidebar: RepoSidebar = self.query_one("#sidebar-container", RepoSidebar)
         sidebar.populate(self.repos)
 
+        fleet: FleetStatus = self.query_one("#fleet-status", FleetStatus)
+        fleet.set_active_filter(category)
+
         if self.repos:
             self._select_repo(self.repos[0])
 
@@ -429,23 +451,20 @@ class GitPulseApp(App):
         if self._selected_repo is None:
             return
 
-        result = switch_branch(self._selected_repo.path, message.branch_name)
-        self.notify(result, timeout=3)
+        path = self._selected_repo.path
+        branch_name = message.branch_name
 
-        # Refresh the selected repo's data
-        updated_info = get_repo_info(self._selected_repo.path)
-        self._select_repo(updated_info)
+        def _do_switch() -> tuple[str, RepoInfo]:
+            msg = switch_branch(path, branch_name)
+            info = get_repo_info(path)
+            return msg, info
 
-        # Also kick off a background rescan to update the sidebar
-        self._start_scan()
+        self.run_worker(_do_switch, thread=True, group="branch_switch", exclusive=False)
 
     def on_main_panel_reload_requested(self, message: MainPanel.ReloadRequested) -> None:
-        """Fired after a commit or branch operation — refresh sidebar entry."""
+        """Fired after a commit or branch operation — rescan to update sidebar."""
         if self._selected_repo is None:
             return
-        updated_info = get_repo_info(self._selected_repo.path)
-        self._selected_repo = updated_info
-        # Rescan to update sidebar badges/timestamps
         self._start_scan()
 
 
@@ -462,8 +481,8 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--root",
         type=str,
-        default=".",
-        help="Root directory to scan for git repos (default: current directory)",
+        default=None,
+        help="Root directory to scan for git repos (default: first entry in config scan.roots, or current directory)",
     )
     parser.add_argument(
         "--commits",
@@ -518,18 +537,22 @@ def main() -> None:
     """Entry point — called by both `python main.py` and the `gitpulse` command."""
     args = parse_args()
 
-    # Load config (custom path takes precedence)
+    # Load config first so scan.roots can influence the default root.
     if args.config:
         _config.load(Path(args.config))
+    cfg = _config.get()
 
-    root = Path(args.root).expanduser().resolve()
+    if args.root is not None:
+        root = Path(args.root).expanduser().resolve()
+    elif cfg.scan.roots:
+        root = Path(cfg.scan.roots[0]).expanduser().resolve()
+    else:
+        root = Path(".").resolve()
 
     if not root.is_dir():
         print(f"Error: '{root}' is not a valid directory.", file=sys.stderr)
         sys.exit(1)
 
-    cfg = _config.get()
-
     if args.digest:
         # CLI digest mode — no TUI
         from gitpulse.scanner import scan_repos as _scan

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/scanner.py

@@ -44,7 +44,8 @@ def scan_repos(root: Path) -> list[Path]:
 
     repos: list[Path] = []
     _walk(root, repos)
-    repos.sort(key=lambda p: p.name.lower())
+    # No alphabetical sort here — the caller (_scan_worker) re-sorts by
+    # commit timestamp, making a pre-sort wasted work.
     return repos
 
 

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/ui/digest_screen.py

@@ -26,13 +26,6 @@ except ImportError:
     from utils import parse_since, relative_time  # type: ignore
 
 
-_WINDOWS = {
-    "1": ("1d", "Today"),
-    "7": ("7d", "7 days"),
-    "3": ("30d", "30 days"),
-}
-
-
 class DigestScreen(ModalScreen):
     """Full-screen activity digest modal."""
 
@@ -134,11 +127,14 @@ class DigestScreen(ModalScreen):
             body.update(f"[bold #ff5252]Error: {e}[/]")
             return
 
-        # Run in a worker so we don't block the UI
+        # Run in a worker so we don't block the UI.
+        # exclusive=True cancels any in-flight digest worker before starting
+        # a new one, preventing a race when the user switches windows rapidly.
         self.run_worker(
             lambda: build_digest(self._repos, since_ts, self._author_patterns),
             thread=True,
             group="digest",
+            exclusive=True,
         )
 
     def on_worker_state_changed(self, event) -> None:

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/ui/fleet_status.py

@@ -79,6 +79,10 @@ class FleetStatus(Widget):
             super().__init__()
             self.category = category
 
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._active_filter: str = ""
+
     def compose(self) -> ComposeResult:
         yield Static("fleet:", id="fleet-label", markup=False)
         yield FleetChip("dirty",   id="chip-dirty")
@@ -111,6 +115,21 @@ class FleetStatus(Widget):
         self._set_chip("chip-stashes", "⊞ stash",   total_stashes, "#4dd0e1")
         self._set_chip("chip-stale",   "☠ stale",   n_stale,       "#e040fb")
 
+    def set_active_filter(self, category: str) -> None:
+        """Highlight the active filter chip and dim the rest."""
+        self._active_filter = category
+        chip_map = {
+            "dirty": "chip-dirty", "behind": "chip-behind",
+            "ahead": "chip-ahead", "stashes": "chip-stashes",
+            "stale": "chip-stale", "all": "chip-all",
+        }
+        for cat, cid in chip_map.items():
+            chip: FleetChip = self.query_one(f"#{cid}", FleetChip)
+            if cat == category and category not in ("all", ""):
+                chip.add_class("-active-filter")
+            else:
+                chip.remove_class("-active-filter")
+
     def _set_chip(self, widget_id: str, label: str, count: int, color: str) -> None:
         chip: FleetChip = self.query_one(f"#{widget_id}", FleetChip)
         if count == 0:

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/ui/stale_screen.py

@@ -1,7 +1,7 @@
 """
 stale_screen.py — Stale-branch cleanup modal for GitPulse.
 
-Opened with 'B' to show branches across all repos matching stale/merged/WIP
+Opened with 'b' to show branches across all repos matching stale/merged/WIP
 criteria. Supports multi-select and bulk delete with a typed confirmation.
 """
 

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/ui/tabs.py

@@ -74,6 +74,19 @@ _ICON_UNSTAGED  = "✏️ "
 _ICON_UNTRACKED = "❓"
 _ICON_STASH     = "📦"
 
+# Module-level constant — avoids rebuilding this dict on every recursive
+# _build() call during Tree tab loading.
+_FILE_ICONS: dict[str, str] = {
+    "py": "🐍", "js": "🟨", "ts": "🟦", "go": "🐹",
+    "rs": "⚙️", "c": "🔧", "cpp": "🔧", "java": "☕",
+    "md": "📝", "rst": "📝", "txt": "📝",
+    "json": "📋", "yaml": "📋", "yml": "📋",
+    "toml": "📋", "ini": "📋", "cfg": "📋", "env": "🔒",
+    "sh": "📜", "bash": "📜", "zsh": "📜",
+    "html": "🌐", "css": "🎨", "tcss": "🎨",
+    "sql": "🗄️",
+}
+
 
 # ===================================================================
 # Modal: Commit dialog
@@ -1008,17 +1021,6 @@ class MainPanel(Widget):
                 _build(child, d[name], f"{prefix}{name}/")
             for name in files:
                 ext = name.rsplit(".", 1)[-1].lower() if "." in name else ""
-                # Language-specific file icons for visual identification
-                _FILE_ICONS = {
-                    "py": "🐍", "js": "🟨", "ts": "🟦", "go": "🐹",
-                    "rs": "⚙️", "c": "🔧", "cpp": "🔧", "java": "☕",
-                    "md": "📝", "rst": "📝", "txt": "📝",
-                    "json": "📋", "yaml": "📋", "yml": "📋",
-                    "toml": "📋", "ini": "📋", "cfg": "📋", "env": "🔒",
-                    "sh": "📜", "bash": "📜", "zsh": "📜",
-                    "html": "🌐", "css": "🎨", "tcss": "🎨",
-                    "sql": "🗄️",
-                }
                 icon = _FILE_ICONS.get(ext, "📄")
                 if ext in ("py", "js", "ts", "go", "rs", "c", "cpp", "java"):
                     label = f"[#3ddc84]{icon} {name}[/]"
@@ -1182,34 +1184,60 @@ class MainPanel(Widget):
         self.post_message(self.ReloadRequested())
 
     def action_fetch(self) -> None:
-        """Fetch from all remotes (f key in Remotes tab)."""
+        """Fetch from all remotes (f key in Remotes tab) — runs in background."""
         if self._current_repo is None:
             return
         self.app.notify("Fetching…", timeout=2)
-        result = git_fetch(self._current_repo)
-        self.app.notify(result, timeout=4)
-        self._reload_tab("tab-remotes")
+        path = self._current_repo
+        self.run_worker(
+            lambda: ("fetch", git_fetch(path)),
+            thread=True, group="git_op", exclusive=False,
+        )
 
     def action_pull(self) -> None:
-        """Pull from the tracking branch (p key in Remotes tab)."""
+        """Pull from the tracking branch (p key in Remotes tab) — runs in background."""
         if self._current_repo is None:
             return
         self.app.notify("Pulling…", timeout=2)
-        result = git_pull(self._current_repo)
-        self.app.notify(result, timeout=5)
-        for tab in ("tab-status", "tab-commits", "tab-remotes"):
-            self._loaded_tabs.discard(tab)
-        self._load_tab(self._active_tab())
-        self.post_message(self.ReloadRequested())
+        path = self._current_repo
+        self.run_worker(
+            lambda: ("pull", git_pull(path)),
+            thread=True, group="git_op", exclusive=False,
+        )
 
     def action_push(self) -> None:
-        """Push to the tracking branch (P key in Remotes tab)."""
+        """Push to the tracking branch (P key in Remotes tab) — runs in background."""
         if self._current_repo is None:
             return
         self.app.notify("Pushing…", timeout=2)
-        result = git_push(self._current_repo)
-        self.app.notify(result, timeout=5)
-        self._reload_tab("tab-remotes")
+        path = self._current_repo
+        self.run_worker(
+            lambda: ("push", git_push(path)),
+            thread=True, group="git_op", exclusive=False,
+        )
+
+    def on_worker_state_changed(self, event) -> None:
+        """Handle results from background git_op workers (fetch/pull/push)."""
+        from textual.worker import WorkerState
+        group = getattr(event.worker, "group", None)
+        if group != "git_op":
+            return
+        event.stop()  # Don't let it bubble to the App's handler
+        if event.state == WorkerState.SUCCESS and event.worker.result is not None:
+            op, result_msg = event.worker.result
+            self.app.notify(result_msg, timeout=5)
+            if op in ("pull", "fetch"):
+                for tab in ("tab-status", "tab-commits", "tab-remotes"):
+                    self._loaded_tabs.discard(tab)
+            else:
+                self._loaded_tabs.discard("tab-remotes")
+            self._load_tab(self._active_tab())
+            self.post_message(self.ReloadRequested())
+        elif event.state == WorkerState.ERROR:
+            self.app.notify(
+                f"Git operation failed: {event.worker.error}",
+                severity="error", timeout=5,
+            )
 
 
     def _delete_selected_branch(self) -> None:

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/utils.py

@@ -14,7 +14,7 @@ from datetime import datetime, timezone, timedelta
 # Package version — single source of truth
 # ---------------------------------------------------------------------------
 
-__version__ = "1.2.4"
+__version__ = "1.2.6"
 
 
 # ---------------------------------------------------------------------------

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/gitpulse/watcher.py

@@ -20,11 +20,12 @@ except ImportError:
     from git_ops import RepoInfo  # type: ignore[no-redef]
 
 
-def repo_signature(repo_path: Path) -> tuple[float, float, float]:
-    """Return (HEAD mtime, index mtime, refs/heads mtime) for *repo_path*.
+def repo_signature(repo_path: Path) -> tuple[float, float, float, float]:
+    """Return (HEAD mtime, index mtime, refs/heads mtime, packed-refs mtime).
 
     Any unreadable path contributes 0.0 so the tuple is always well-typed.
-    Missing files won't cause false positives after the first stable snapshot.
+    packed-refs is checked alongside refs/heads because cloned or gc'd repos
+    store references there rather than as individual files under refs/heads/.
     """
     def _mtime(p: Path) -> float:
         try:
@@ -37,17 +38,18 @@ def repo_signature(repo_path: Path) -> tuple[float, float, float]:
         _mtime(git_dir / "HEAD"),
         _mtime(git_dir / "index"),
         _mtime(git_dir / "refs" / "heads"),
+        _mtime(git_dir / "packed-refs"),
     )
 
 
-def snapshot(repos: list[RepoInfo]) -> dict[Path, tuple[float, float, float]]:
+def snapshot(repos: list[RepoInfo]) -> dict[Path, tuple[float, float, float, float]]:
     """Build a path → signature map for all repos. O(N) stat calls."""
     return {r.path: repo_signature(r.path) for r in repos}
 
 
 def changed_repos(
     repos: list[RepoInfo],
-    previous: dict[Path, tuple[float, float, float]],
+    previous: dict[Path, tuple[float, float, float, float]],
 ) -> list[RepoInfo]:
     """Return repos whose signature differs from *previous*.
 

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6/gitpulse_tui.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpulse-tui
-Version: 1.2.4
+Version: 1.2.6
 Summary: Git Repo Dashboard TUI — live status, commits, diffs, and branches in your terminal
 Requires-Python: >=3.10
 License-File: LICENSE

{gitpulse_tui-1.2.4 → gitpulse_tui-1.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitpulse-tui"
-version = "1.2.4"
+version = "1.2.6"
 description = "Git Repo Dashboard TUI — live status, commits, diffs, and branches in your terminal"
 requires-python = ">=3.10"
 dependencies = [