aline-ai 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

realign/dashboard/widgets/sessions_table.py

@@ -17,7 +17,7 @@ from textual.binding import Binding
 from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
 from textual.worker import Worker, WorkerState
-from textual.widgets import Button, DataTable, Static
+from textual.widgets import Button, DataTable, Select, Static
 
 from ...logging_config import setup_logger
 from .openable_table import OpenableDataTable
@@ -80,23 +80,16 @@ class SessionsTable(Container):
     }
 
     SessionsTable .table-container {
-        height: auto;
+        height: 1fr;
         overflow-x: auto;
-        overflow-y: hidden;
+        overflow-y: auto;
     }
 
     SessionsTable DataTable {
         height: auto;
         max-height: 100%;
         overflow-x: auto;
-        overflow-y: hidden;
-    }
-
-    SessionsTable .pagination-info {
-        height: 1;
-        margin-top: 1;
-        color: $text-muted;
-        text-align: center;
+        overflow-y: auto;
     }
 
     SessionsTable .stats-info {
@@ -107,9 +100,9 @@ class SessionsTable(Container):
     """
 
     # Reactive properties
-    current_page: reactive[int] = reactive(1)
-    rows_per_page: reactive[int] = reactive(10)
     wrap_mode: reactive[bool] = reactive(False)
+    # Maximum sessions to load (for scrollable list)
+    MAX_SESSIONS: int = 500
 
     def __init__(self) -> None:
         super().__init__()
@@ -123,8 +116,9 @@ class SessionsTable(Container):
         self._refresh_worker: Optional[Worker] = None
         self._share_export_worker: Optional[Worker] = None
         self._refresh_timer = None
-        self._active_refresh_snapshot: Optional[tuple[int, int]] = None
-        self._pending_refresh_snapshot: Optional[tuple[int, int]] = None
+        self._is_refreshing: bool = False
+        self._pending_refresh: bool = False
+        self._saved_cursor_session_id: Optional[str] = None
 
     def compose(self) -> ComposeResult:
         """Compose the sessions table layout."""
@@ -144,7 +138,6 @@ class SessionsTable(Container):
         yield Static(id="section-header", classes="section-header")
         with Container(classes="table-container"):
             yield SessionsListTable(id="sessions-table")
-        yield Static(id="pagination-info", classes="pagination-info")
         yield Static(id="stats-info", classes="stats-info")
 
     def on_mount(self) -> None:
@@ -155,22 +148,19 @@ class SessionsTable(Container):
             table.owner = self
 
             self._setup_table_columns(table)
-
-            # Calculate initial rows per page
-            self._calculate_rows_per_page()
             logger.debug("SessionsTable.on_mount() completed")
         except Exception as e:
             logger.error(f"SessionsTable.on_mount() failed: {e}\n{traceback.format_exc()}")
             raise
 
     def on_resize(self) -> None:
-        """Handle window resize to adjust rows per page."""
-        self._sync_to_available_height()
+        """Handle window resize."""
+        pass  # No longer need to recalculate pagination
 
     def on_show(self) -> None:
-        """Re-sync pagination when the tab becomes visible."""
+        """Refresh data when the tab becomes visible."""
         if self._refresh_timer is None:
-            self._refresh_timer = self.set_interval(5.0, self._on_refresh_timer)
+            self._refresh_timer = self.set_interval(60.0, self._on_refresh_timer)
         else:
             try:
                 self._refresh_timer.resume()
@@ -188,9 +178,7 @@ class SessionsTable(Container):
             pass
 
     def _on_became_visible(self) -> None:
-        self._sync_to_available_height()
         self._load_sessions()
-        self._update_display()
         try:
             self.query_one("#sessions-table", DataTable).focus()
         except Exception:
@@ -229,19 +217,6 @@ class SessionsTable(Container):
         table.add_column("Last Activity", key="last_activity", width=12)
         table.cursor_type = "row"
 
-    def _sync_to_available_height(self) -> None:
-        """Recalculate rows per page and reload if the page size changed."""
-        old_rows_per_page = self.rows_per_page
-        self._calculate_rows_per_page()
-
-        if self.rows_per_page != old_rows_per_page:
-            total_pages = self._get_total_pages()
-            if self.current_page > total_pages:
-                self.current_page = total_pages
-            self._load_sessions()
-
-        self._update_display()
-
     def get_selected_session_ids(self) -> list[str]:
         return sorted(self._selected_session_ids)
 
@@ -423,47 +398,6 @@ class SessionsTable(Container):
             self._start_share_export()
             return
 
-    def _calculate_rows_per_page(self) -> None:
-        """Calculate rows per page based on available height."""
-        try:
-            panel_height = self.size.height
-
-            # Calculate exact space needed:
-            # - Summary section: ~2 lines content + 2 border + 2 padding + 1 margin = 7
-            # - Section header: 1 line + 1 margin = 2
-            # - Table header row: 1
-            # - Pagination info: 1 line + 1 margin = 2
-            # - Panel padding: 2 (top + bottom)
-            # - Extra buffer: 3
-
-            fixed_height = 7 + 2 + 1 + 2 + 2 + 3  # = 17
-
-            available_for_rows = panel_height - fixed_height
-            rows = max(available_for_rows, 3)  # At least 3 rows
-
-            self.rows_per_page = rows
-        except Exception:
-            self.rows_per_page = 10
-
-    def _get_total_pages(self) -> int:
-        """Calculate total pages."""
-        if self._total_sessions == 0:
-            return 1
-        return (self._total_sessions + self.rows_per_page - 1) // self.rows_per_page
-
-    def action_next_page(self) -> None:
-        """Go to next page."""
-        total_pages = self._get_total_pages()
-        if self.current_page < total_pages:
-            self.current_page += 1
-            self._load_sessions()
-
-    def action_prev_page(self) -> None:
-        """Go to previous page."""
-        if self.current_page > 1:
-            self.current_page -= 1
-            self._load_sessions()
-
     def _on_refresh_timer(self) -> None:
         self.refresh_data(force=False)
 
@@ -472,26 +406,37 @@ class SessionsTable(Container):
         if not self.display:
             return
 
-        snapshot = (int(self.current_page), int(self.rows_per_page))
         if self._refresh_worker is not None and self._refresh_worker.state in (
             WorkerState.PENDING,
             WorkerState.RUNNING,
         ):
             if force:
-                self._pending_refresh_snapshot = snapshot
+                self._pending_refresh = True
             return
 
-        if force and self._pending_refresh_snapshot is not None:
-            snapshot = self._pending_refresh_snapshot
-            self._pending_refresh_snapshot = None
+        # Save current cursor position before refresh
+        self._save_cursor_position()
 
         def work() -> dict:
-            return self._collect_snapshot(*snapshot)
+            return self._collect_all_sessions()
 
-        self._active_refresh_snapshot = snapshot
-        self._pending_refresh_snapshot = None
+        self._is_refreshing = True
+        self._pending_refresh = False
         self._refresh_worker = self.run_worker(work, thread=True, exit_on_error=False)
 
+    def _save_cursor_position(self) -> None:
+        """Save the current cursor session ID to restore after refresh."""
+        try:
+            table = self.query_one("#sessions-table", DataTable)
+            if table.row_count > 0:
+                self._saved_cursor_session_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
+            else:
+                self._saved_cursor_session_id = None
+        except Exception:
+            self._saved_cursor_session_id = None
+
     def _load_sessions(self) -> None:
         """Compatibility hook (tests stub this); default triggers async refresh."""
         if not self.is_mounted:
@@ -513,35 +458,34 @@ class SessionsTable(Container):
 
         if event.state == WorkerState.ERROR:
             result = {
-                "snapshot": self._active_refresh_snapshot,
                 "total_sessions": 0,
                 "stats": {},
                 "sessions": [],
             }
+            self._is_refreshing = False
         elif event.state != WorkerState.SUCCESS:
             return
         else:
             result = self._refresh_worker.result or {}
+            self._is_refreshing = False
 
-        snapshot = result.get("snapshot")
-        if snapshot == (int(self.current_page), int(self.rows_per_page)):
-            try:
-                self._total_sessions = int(result.get("total_sessions") or 0)
-            except Exception:
-                self._total_sessions = 0
-            try:
-                self._stats = dict(result.get("stats") or {})
-            except Exception:
-                self._stats = {}
-            try:
-                self._sessions = list(result.get("sessions") or [])
-                self._sessions_by_id = {s["id"]: s for s in self._sessions}
-            except Exception:
-                self._sessions = []
-                self._sessions_by_id = {}
-            self._update_display()
+        try:
+            self._total_sessions = int(result.get("total_sessions") or 0)
+        except Exception:
+            self._total_sessions = 0
+        try:
+            self._stats = dict(result.get("stats") or {})
+        except Exception:
+            self._stats = {}
+        try:
+            self._sessions = list(result.get("sessions") or [])
+            self._sessions_by_id = {s["id"]: s for s in self._sessions}
+        except Exception:
+            self._sessions = []
+            self._sessions_by_id = {}
+        self._update_display()
 
-        if self._pending_refresh_snapshot is not None:
+        if self._pending_refresh:
             self.refresh_data()
 
     def _start_share_export(self) -> None:
@@ -772,8 +716,8 @@ class SessionsTable(Container):
         suffix = " (copied to clipboard)" if copied else ""
         self.app.notify(f"Share link created{suffix}", title="Share", timeout=4)
 
-    def _collect_snapshot(self, page: int, rows_per_page: int) -> dict:
-        """Collect sessions + stats for a single page (background thread)."""
+    def _collect_all_sessions(self) -> dict:
+        """Collect all sessions + stats (background thread)."""
         total_sessions: int = 0
         stats: dict = {}
         sessions: list[dict] = []
@@ -810,9 +754,7 @@ class SessionsTable(Container):
                     "gemini": stats_row[3] if stats_row else 0,
                 }
 
-                # Get paginated sessions
-                # Use cached total_turns instead of subquery for performance
-                offset = (int(page) - 1) * int(rows_per_page)
+                # Get all sessions (up to MAX_SESSIONS)
                 try:
                     rows = conn.execute(
                         """
@@ -827,9 +769,9 @@ class SessionsTable(Container):
                             s.shared_by
                         FROM sessions s
                         ORDER BY s.last_activity_at DESC
-                        LIMIT ? OFFSET ?
+                        LIMIT ?
                     """,
-                        (int(rows_per_page), int(offset)),
+                        (self.MAX_SESSIONS,),
                     ).fetchall()
                     has_new_columns = True
                 except Exception:
@@ -845,9 +787,9 @@ class SessionsTable(Container):
                             s.total_turns
                         FROM sessions s
                         ORDER BY s.last_activity_at DESC
-                        LIMIT ? OFFSET ?
+                        LIMIT ?
                     """,
-                        (int(rows_per_page), int(offset)),
+                        (self.MAX_SESSIONS,),
                     ).fetchall()
                     has_new_columns = False
 
@@ -869,7 +811,6 @@ class SessionsTable(Container):
                         "claude": "Claude",
                         "codex": "Codex",
                         "gemini": "Gemini",
-                        "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
                     project = Path(workspace).name if workspace else "-"
@@ -904,7 +845,7 @@ class SessionsTable(Container):
 
                     sessions.append(
                         {
-                            "index": offset + i + 1,
+                            "index": i + 1,
                             "id": session_id,
                             "short_id": self._shorten_session_id(session_id),
                             "source": source,
@@ -917,13 +858,12 @@ class SessionsTable(Container):
                         }
                     )
         except Exception as e:
-            logger.error(f"_collect_snapshot failed: {e}\n{traceback.format_exc()}")
+            logger.error(f"_collect_all_sessions failed: {e}\n{traceback.format_exc()}")
             total_sessions = 0
             stats = {}
             sessions = []
 
         return {
-            "snapshot": (int(page), int(rows_per_page)),
             "total_sessions": total_sessions,
             "stats": stats,
             "sessions": sessions,
@@ -939,18 +879,23 @@ class SessionsTable(Container):
 
         # Update table
         table = self.query_one("#sessions-table", DataTable)
-        selected_session_id: Optional[str] = None
-        try:
-            if table.row_count > 0:
-                selected_session_id = str(
-                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
-                )
-        except Exception:
-            selected_session_id = None
+
+        # Use saved cursor position if available, otherwise try to get current
+        restore_session_id = self._saved_cursor_session_id
+        if restore_session_id is None:
+            try:
+                if table.row_count > 0:
+                    restore_session_id = str(
+                        table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                    )
+            except Exception:
+                restore_session_id = None
+
         table.clear()
 
-        # Always enable horizontal scrollbar
+        # Always enable scrollbars
         table.styles.overflow_x = "auto"
+        table.styles.overflow_y = "auto"
         table.show_horizontal_scrollbar = True
 
         for session in self._sessions:
@@ -979,10 +924,10 @@ class SessionsTable(Container):
             )
 
         if table.row_count > 0:
-            if selected_session_id:
+            if restore_session_id:
                 try:
                     table.cursor_coordinate = (
-                        table.get_row_index(selected_session_id),
+                        table.get_row_index(restore_session_id),
                         0,
                     )
                 except Exception:
@@ -990,12 +935,8 @@ class SessionsTable(Container):
             else:
                 table.cursor_coordinate = (0, 0)
 
-        # Update pagination info
-        total_pages = self._get_total_pages()
-        pagination_widget = self.query_one("#pagination-info", Static)
-        pagination_widget.update(
-            f"[dim]Page {self.current_page}/{total_pages} ({self._total_sessions} total)  │  (p) prev  (n) next[/dim]"
-        )
+        # Clear saved cursor position after restore
+        self._saved_cursor_session_id = None
 
     def _shorten_session_id(self, session_id: str) -> str:
         """Shorten a session ID for display."""