gitdirector 1.4.0__tar.gz → 1.4.2__tar.gz

{gitdirector-1.4.0 → gitdirector-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gitdirector
-Version: 1.4.0
+Version: 1.4.2
 Summary: A terminal based control plane for developers working across multiple repositories. Launch multiple AI coding agents, multiple tmux sessions and track changes across all your repos in one place.
 Keywords: git,repository,manager,cli,synchronization,batch
 Author: Anito Anto

{gitdirector-1.4.0 → gitdirector-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "gitdirector"
-version = "1.4.0"
+version = "1.4.2"
 description = "A terminal based control plane for developers working across multiple repositories. Launch multiple AI coding agents, multiple tmux sessions and track changes across all your repos in one place."
 readme = "README.md"
 license = { text = "MIT" }

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/cli.py

@@ -14,6 +14,7 @@ from .commands import (
     info,
     link,
     listt,
+    print_update_notice,
     pull,
     status,
     tui,
@@ -39,6 +40,7 @@ class _HelpGroup(click.Group):
 @click.group(cls=_HelpGroup, invoke_without_command=True)
 @click.pass_context
 def cli(ctx):
+    print_update_notice()
     if ctx.invoked_subcommand is None:
         show_help()
 

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/__init__.py

@@ -1,17 +1,17 @@
 from typing import Optional
 
+import click
 from rich import box
 from rich.console import Console
 from rich.table import Table
 from rich.text import Text
 
+from .. import version_check
 from ..repo import RepoStatus
 
 
 def _get_version() -> str:
-    from importlib.metadata import version
-
-    return version("gitdirector")
+    return version_check.get_installed_version()
 
 
 __version__: Optional[str] = None
@@ -24,6 +24,23 @@ def get_version() -> str:
     return __version__
 
 
+def print_update_notice() -> None:
+    ctx = click.get_current_context(silent=True)
+    if ctx is not None:
+        root_ctx = ctx.find_root()
+        if root_ctx.meta.get("update_notice_printed"):
+            return
+        root_ctx.meta["update_notice_printed"] = True
+
+    notice = version_check.get_update_notice()
+    if notice is None:
+        return
+
+    console.print()
+    console.print(f" [yellow]{notice}[/yellow]")
+    console.print()
+
+
 console = Console(highlight=False)
 
 _STATUS_COLOR = {

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/help.py

@@ -1,10 +1,11 @@
 import click
 from rich.table import Table
 
-from . import console, get_version
+from . import console, get_version, print_update_notice
 
 
 def show_help():
+    print_update_notice()
     console.print()
     console.print(
         f" [bold white]GITDIRECTOR[/bold white]  "

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/app.py

@@ -13,6 +13,7 @@ from textual.binding import Binding
 from textual.containers import Horizontal
 from textual.widgets import DataTable, Footer, Header, Input, Static, TabbedContent, TabPane
 
+from ... import version_check
 from ...manager import RepositoryManager
 from ...repo import Repository, RepositoryInfo
 from .. import get_version
@@ -25,6 +26,7 @@ from .constants import (
     _DEFAULT_PANELS_SORT_COLUMN,
     _DEFAULT_SESSIONS_SORT_COLUMN,
     _DEFAULT_SORT_COLUMN,
+    _SESSION_STATUS_POLL_INTERVAL_SECS,
 )
 from .panels import Panel, PanelStore
 from .screens import (
@@ -205,7 +207,10 @@ class GitDirectorConsole(
         self._resume_selection_row: int | None = None
         self._resume_new_panel_guard_until: float = 0.0
         self._panel_store = PanelStore()
+        self._status_message = "Loading repositories…"
+        self._update_notice = version_check.get_cached_update_notice()
         self._session_status_tracking_paused = False
+        self._session_status_tracking_running = False
 
     def compose(self) -> ComposeResult:
         yield Header(show_clock=True)
@@ -236,7 +241,7 @@ class GitDirectorConsole(
         with Horizontal(id="search-container"):
             yield Static("/ search:", id="search-label")
             yield Input(placeholder="type to filter…", id="search-bar")
-        yield Static("Loading repositories…", id="status-bar")
+        yield Static(self._compose_status_message(self._status_message), id="status-bar")
         yield Footer()
 
     def on_mount(self) -> None:
@@ -254,10 +259,22 @@ class GitDirectorConsole(
         )
         self.app_resume_signal.subscribe(self, self._handle_app_resume)
         self._sync_tmux_theme_config(self.theme)
-        self._poll_timer = self.set_interval(3, self._trigger_status_poll)
-        self._monitor.start()
+        self._poll_timer = self.set_interval(
+            _SESSION_STATUS_POLL_INTERVAL_SECS,
+            self._trigger_status_poll,
+        )
+        self._set_session_status_tracking_running(False)
+        self._load_update_notice()
         self._load_repos()
-        self._trigger_status_poll()
+
+    @work(thread=True)
+    def _load_update_notice(self) -> None:
+        notice = version_check.format_update_notice(version_check.get_update_status())
+        self.call_from_thread(self._set_update_notice, notice)
+
+    def _set_update_notice(self, notice: str | None) -> None:
+        self._update_notice = notice
+        self._refresh_status_bar()
 
     def _sync_tmux_theme_config(self, theme_name: str | None = None) -> None:
         from ...integrations.tmux import sync_panel_tmux_config

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/app_repos.py

@@ -87,6 +87,13 @@ class ConsoleReposMixin:
 
     def _populate_initial_rows(self) -> None:
         table = self.query_one("#repo-table", DataTable)
+        preserved_row_key = None
+        preserved_row_index = None
+        restore_focus = False
+        if self._resume_selection_tab != "repos":
+            preserved_row_key, preserved_row_index, restore_focus = self._capture_table_selection(
+                table
+            )
         table.clear()
         for path in self._repo_paths:
             table.add_row(
@@ -99,7 +106,16 @@ class ConsoleReposMixin:
                 str(path),
                 key=str(path),
             )
+
+        if self._resume_selection_tab == "repos":
             self._restore_resume_selection("repos")
+        else:
+            self._restore_table_selection(
+                table,
+                preserved_row_key,
+                preserved_row_index,
+                restore_focus=restore_focus,
+            )
 
     def _update_row(self, info: RepositoryInfo, sessions: int = 0) -> None:
         self._sessions_cache[str(info.path)] = sessions
@@ -138,6 +154,13 @@ class ConsoleReposMixin:
 
     def _apply_filter_and_sort(self) -> None:
         table = self.query_one("#repo-table", DataTable)
+        preserved_row_key = None
+        preserved_row_index = None
+        restore_focus = False
+        if self._resume_selection_tab != "repos":
+            preserved_row_key, preserved_row_index, restore_focus = self._capture_table_selection(
+                table
+            )
         table.clear()
 
         infos = list(self._results.values())
@@ -168,7 +191,15 @@ class ConsoleReposMixin:
                 key=str(info.path),
             )
 
-        self._restore_resume_selection("repos")
+        if self._resume_selection_tab == "repos":
+            self._restore_resume_selection("repos")
+        else:
+            self._restore_table_selection(
+                table,
+                preserved_row_key,
+                preserved_row_index,
+                restore_focus=restore_focus,
+            )
         self._update_status(self._build_loaded_status(len(infos), total))
 
     def _build_loaded_status(self, shown: int, total: int) -> str:
@@ -202,10 +233,11 @@ class ConsoleReposMixin:
         return msg
 
     def action_refresh(self) -> None:
-        self._results.clear()
-        self._sessions_cache.clear()
-        self._load_repos()
         if self._active_tab == "sessions":
             self._load_sessions()
         elif self._active_tab == "panels":
             self._load_panels()
+        else:
+            self._results.clear()
+            self._sessions_cache.clear()
+            self._load_repos()

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/app_sessions.py

@@ -39,6 +39,13 @@ class ConsoleSessionsMixin:
             table = self.query_one("#sessions-table", DataTable)
         except NoMatches:
             return
+        preserved_row_key = None
+        preserved_row_index = None
+        restore_focus = False
+        if self._resume_selection_tab != "sessions":
+            preserved_row_key, preserved_row_index, restore_focus = self._capture_table_selection(
+                table
+            )
         table.clear()
         no_msg = self.query_one("#no-sessions-message", Static)
 
@@ -86,7 +93,15 @@ class ConsoleSessionsMixin:
                     key=entry["session_name"],
                 )
 
-        self._restore_resume_selection("sessions")
+        if self._resume_selection_tab == "sessions":
+            self._restore_resume_selection("sessions")
+        else:
+            self._restore_table_selection(
+                table,
+                preserved_row_key,
+                preserved_row_index,
+                restore_focus=restore_focus,
+            )
         self._update_status(self._build_sessions_loaded_status(len(entries), total))
 
     def _build_sessions_loaded_status(self, shown: int, total: int) -> str:
@@ -121,31 +136,54 @@ class ConsoleSessionsMixin:
             msg += "  [esc] clear search"
         return msg
 
+    def _should_run_session_status_tracking(self) -> bool:
+        return self._active_tab == "sessions" and not self._session_status_tracking_paused
+
+    def _set_session_status_tracking_running(self, running: bool) -> None:
+        poll_timer = getattr(self, "_poll_timer", None)
+
+        if running:
+            if self._session_status_tracking_running:
+                return
+            self._monitor.start()
+            if poll_timer is not None:
+                poll_timer.resume()
+            self._session_status_tracking_running = True
+            return
+
+        if poll_timer is not None:
+            poll_timer.pause()
+        if self._session_status_tracking_running:
+            self._monitor.stop()
+        self._session_status_tracking_running = False
+
+    def _sync_session_status_tracking(self) -> None:
+        self._set_session_status_tracking_running(self._should_run_session_status_tracking())
+
     def _pause_session_status_tracking(self) -> None:
         if self._session_status_tracking_paused:
             return
         self._session_status_tracking_paused = True
-        poll_timer = getattr(self, "_poll_timer", None)
-        if poll_timer is not None:
-            poll_timer.pause()
-        self._monitor.stop()
+        self._set_session_status_tracking_running(False)
 
     def _resume_session_status_tracking(self) -> None:
         if not self._session_status_tracking_paused:
             return
         self._session_status_tracking_paused = False
-        self._monitor.start()
-        poll_timer = getattr(self, "_poll_timer", None)
-        if poll_timer is not None:
-            poll_timer.resume()
+        self._sync_session_status_tracking()
 
     def _trigger_status_poll(self) -> None:
+        if not self._should_run_session_status_tracking():
+            return
         self._poll_session_statuses()
 
     @work(thread=True, exclusive=True, group="status_poll")
     def _poll_session_statuses(self) -> None:
         from ...integrations.tmux import get_all_session_statuses, list_all_gd_sessions
 
+        if not self._should_run_session_status_tracking():
+            return
+
         entries = list_all_gd_sessions()
         statuses = get_all_session_statuses()
         self._session_statuses = statuses

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/app_ui.py

@@ -24,6 +24,22 @@ logger = logging.getLogger(__name__)
 
 
 class ConsoleUIHelpersMixin:
+    def _compose_status_message(self, message: str) -> str:
+        notice = getattr(self, "_update_notice", None)
+        if not notice:
+            return message
+        if not message:
+            return notice
+        return f"{message}  |  {notice}"
+
+    def _refresh_status_bar(self) -> None:
+        try:
+            self.query_one("#status-bar", Static).update(
+                self._compose_status_message(self._status_message)
+            )
+        except NoMatches:
+            return
+
     def action_tab_repos(self) -> None:
         if self._resume_target_tab is not None and self._resume_target_tab != "repos":
             return
@@ -66,6 +82,7 @@ class ConsoleUIHelpersMixin:
             self._resume_tab_activation_guard = None
             self._active_tab = tab_id
             self.refresh_bindings()
+            self._sync_session_status_tracking()
             return
         if self._resume_target_tab is not None:
             if tab_id != self._resume_target_tab:
@@ -73,9 +90,11 @@ class ConsoleUIHelpersMixin:
                 return
             self._active_tab = tab_id
             self.refresh_bindings()
+            self._sync_session_status_tracking()
             return
         self._active_tab = tab_id
         self.refresh_bindings()
+        self._sync_session_status_tracking()
         if tab_id == "sessions":
             self._load_sessions()
         elif tab_id == "panels":
@@ -123,6 +142,7 @@ class ConsoleUIHelpersMixin:
             tabs.active = restore_tab
         self._active_tab = restore_tab
         self.refresh_bindings()
+        self._sync_session_status_tracking()
 
         if restore_tab == "sessions":
             self._load_sessions()
@@ -144,7 +164,8 @@ class ConsoleUIHelpersMixin:
             self._refresh_repo_for_path(restore_path)
 
     def _update_status(self, message: str) -> None:
-        self.query_one("#status-bar", Static).update(message)
+        self._status_message = message
+        self._refresh_status_bar()
 
     def _update_search_indicator(self) -> None:
         repo_ind = self.query_one("#repo-search-indicator", Static)

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/constants.py

@@ -54,6 +54,8 @@ _SESSIONS_SORT_COLUMN_NAMES = {
 
 _DEFAULT_SESSIONS_SORT_COLUMN = 3
 
+_SESSION_STATUS_POLL_INTERVAL_SECS = 10
+
 _PANELS_SORT_COLUMN_NAMES = {
     0: "Name",
     1: "TMUX",

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/commands/tui/screens.py

@@ -98,7 +98,9 @@ class ActionMenuScreen(ModalScreen[str]):
                 items.extend(
                     [
                         Option("", disabled=True),
-                        Option("[white]✕[/white] [dim]Remove Session…[/dim]", id="remove_session"),
+                        Option(
+                            "[white]✕[/white] [dim]Remove Session...[/dim]", id="remove_session"
+                        ),
                     ]
                 )
             yield OptionList(*items, id="action-menu")
@@ -537,7 +539,7 @@ class PullLoadingScreen(ModalScreen[None]):
             yield LoadingIndicator()
             yield Static(f"Pulling [bold]{escape(self.repo_name)}[/bold]", id="pull-loading-title")
             yield Static(f"[dim]{escape(self.command)}[/dim]", id="pull-loading-command")
-            yield Static("please wait…", id="pull-loading-hint")
+            yield Static("please wait...", id="pull-loading-hint")
 
 
 class SortMenuScreen(ModalScreen[tuple | None]):
@@ -998,7 +1000,7 @@ class CreatePanelScreen(ModalScreen[tuple[str, str, dict[int, str | None]] | Non
                     )
                 else:
                     yield Static("[dim]Name[/dim]", id="panel-name-label")
-                    yield Input(placeholder="panel name…", id="panel-name-input")
+                    yield Input(placeholder="panel name...", id="panel-name-input")
                 with Horizontal(id="step-1-columns"):
                     with Vertical(id="step-1-left"):
                         yield Static("[dim]Layout[/dim]", classes="section-label")

{gitdirector-1.4.0 → gitdirector-1.4.2}/src/gitdirector/integrations/tmux/monitor.py

@@ -69,9 +69,9 @@ _SHELL_COMMANDS = frozenset(
 
 _AGENT_PURPOSES = frozenset({"opencode", "claude", "copilot", "codex"})
 
-_SILENCE_THRESHOLD_SECS = 8
+_SILENCE_THRESHOLD_SECS = 11
 _BELL_GRACE_SECS = 1.0
-_CONTENT_POLL_SECS = 2
+_CONTENT_POLL_SECS = 10
 
 
 def _normalize_process_command(raw_args: str) -> str:
@@ -440,7 +440,7 @@ class TmuxMonitor:
             except Exception:
                 pass
 
-            for _ in range(20):
+            for _ in range(_CONTENT_POLL_SECS * 10):
                 if not self._running:
                     return
                 time.sleep(0.1)

gitdirector-1.4.2/src/gitdirector/version_check.py

@@ -0,0 +1,170 @@
+"""PyPI release checking with a short local cache."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
+from pathlib import Path
+from urllib.request import urlopen
+
+from .storage import advisory_file_lock, load_yaml_mapping, write_yaml_atomic
+
+try:
+    from packaging.version import InvalidVersion, Version
+except ImportError:  # pragma: no cover - optional dependency
+    InvalidVersion = ValueError
+    Version = None
+
+_PACKAGE_NAME = "gitdirector"
+_PYPI_JSON_URL = f"https://pypi.org/pypi/{_PACKAGE_NAME}/json"
+_VERSION_CACHE_TTL = timedelta(hours=6)
+_VERSION_CHECK_TIMEOUT_SECS = 1.0
+_VERSION_RE = re.compile(r"^v?(?P<release>\d+(?:\.\d+)*)(?P<suffix>.*)$", re.IGNORECASE)
+_SUFFIX_RANK = {
+    "dev": 0,
+    "a": 1,
+    "alpha": 1,
+    "b": 2,
+    "beta": 2,
+    "rc": 3,
+    "c": 3,
+    "": 4,
+    "post": 5,
+    "rev": 5,
+    "r": 5,
+}
+
+
+@dataclass(frozen=True)
+class UpdateStatus:
+    current_version: str
+    latest_version: str | None
+
+    @property
+    def update_available(self) -> bool:
+        if not self.latest_version:
+            return False
+        return _is_version_newer(self.latest_version, self.current_version)
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _cache_paths() -> tuple[Path, Path]:
+    cache_dir = Path.home() / ".gitdirector"
+    return cache_dir / "version_check.yaml", cache_dir / "version_check.lock"
+
+
+def _parse_checked_at(raw_value: object) -> datetime | None:
+    if not isinstance(raw_value, str) or not raw_value.strip():
+        return None
+    try:
+        parsed = datetime.fromisoformat(raw_value)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _read_cache() -> tuple[datetime | None, str | None]:
+    cache_path, lock_path = _cache_paths()
+    with advisory_file_lock(lock_path):
+        data = load_yaml_mapping(cache_path, description="GitDirector version cache")
+    checked_at = _parse_checked_at(data.get("checked_at"))
+    latest_version = data.get("latest_version")
+    if not isinstance(latest_version, str) or not latest_version.strip():
+        latest_version = None
+    return checked_at, latest_version
+
+
+def _write_cache(checked_at: datetime, latest_version: str | None) -> None:
+    cache_path, lock_path = _cache_paths()
+    data: dict[str, object] = {"checked_at": checked_at.isoformat()}
+    if latest_version:
+        data["latest_version"] = latest_version
+    with advisory_file_lock(lock_path):
+        write_yaml_atomic(cache_path, data)
+
+
+def _fetch_latest_version() -> str | None:
+    with urlopen(_PYPI_JSON_URL, timeout=_VERSION_CHECK_TIMEOUT_SECS) as response:
+        payload = json.load(response)
+    latest_version = payload.get("info", {}).get("version")
+    if not isinstance(latest_version, str) or not latest_version.strip():
+        return None
+    return latest_version.strip()
+
+
+def _fallback_version_key(version: str) -> tuple[tuple[int, ...], int, tuple[int, ...]]:
+    normalized = version.strip().lower()
+    match = _VERSION_RE.match(normalized)
+    if match is None:
+        return (0,), 0, ()
+
+    release = tuple(int(part) for part in match.group("release").split("."))
+    suffix = match.group("suffix").strip(".-+_").lower()
+    if not suffix:
+        return release, _SUFFIX_RANK[""], ()
+
+    tokens = re.findall(r"[a-z]+|\d+", suffix)
+    label = next((token for token in tokens if token.isalpha()), "")
+    numbers = tuple(int(token) for token in tokens if token.isdigit())
+    return release, _SUFFIX_RANK.get(label, 0), numbers
+
+
+def _is_version_newer(latest_version: str, current_version: str) -> bool:
+    if Version is not None:
+        try:
+            return Version(latest_version) > Version(current_version)
+        except InvalidVersion:
+            pass
+    return _fallback_version_key(latest_version) > _fallback_version_key(current_version)
+
+
+@lru_cache(maxsize=1)
+def get_installed_version() -> str:
+    from importlib.metadata import version
+
+    return version(_PACKAGE_NAME)
+
+
+def get_cached_update_status() -> UpdateStatus | None:
+    _, latest_version = _read_cache()
+    return UpdateStatus(get_installed_version(), latest_version)
+
+
+def get_update_status() -> UpdateStatus | None:
+    current_version = get_installed_version()
+    now = _utcnow()
+    checked_at, cached_latest_version = _read_cache()
+
+    if checked_at is not None and now - checked_at <= _VERSION_CACHE_TTL:
+        return UpdateStatus(current_version, cached_latest_version)
+
+    latest_version = cached_latest_version
+    try:
+        latest_version = _fetch_latest_version()
+    except Exception:
+        pass
+
+    _write_cache(now, latest_version)
+    return UpdateStatus(current_version, latest_version)
+
+
+def format_update_notice(status: UpdateStatus | None) -> str | None:
+    if status is None or not status.update_available or not status.latest_version:
+        return None
+    return f"Update available: v{status.latest_version} (current v{status.current_version})"
+
+
+def get_cached_update_notice() -> str | None:
+    return format_update_notice(get_cached_update_status())
+
+
+def get_update_notice() -> str | None:
+    return format_update_notice(get_update_status())