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

realign/dashboard/widgets/sessions_table.py

@@ -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."""

realign/dashboard/widgets/watcher_panel.py

@@ -318,7 +318,6 @@ class WatcherPanel(Container, can_focus=True):
                 ("Claude", "~/.claude/projects/", config.auto_detect_claude),
                 ("Codex", "~/.codex/sessions/", config.auto_detect_codex),
                 ("Gemini", "~/.gemini/tmp/", config.auto_detect_gemini),
-                ("Antigravity", "~/.gemini/antigravity/brain/", config.auto_detect_antigravity),
             ]
         except Exception:
             monitored_paths = []
@@ -426,7 +425,6 @@ class WatcherPanel(Container, can_focus=True):
                     "claude": "Claude",
                     "codex": "Codex",
                     "gemini": "Gemini",
-                    "antigravity": "Antigravity",
                 }
                 source = source_map.get(session_type, session_type)
                 project = Path(workspace).name if workspace else "-"

realign/db/sqlite_db.py

@@ -999,8 +999,7 @@ class SQLiteDatabase(DatabaseInterface):
         # - If the caller requested regeneration (`skip_dedup=True`), we must allow requeue.
         # - If the DB is missing the corresponding turn row (historical bug / manual DB edits),
         #   requeue so the system can self-heal instead of getting stuck in a "done but missing" state.
-        # - For antigravity, turns may update-in-place, so allow requeue even if done.
-        requeue_done = bool(skip_dedup) or (session_type or "").lower() in ("antigravity",)
+        requeue_done = bool(skip_dedup)
         try:
             conn = self._get_connection()
             row = conn.execute(

realign/events/event_summarizer.py

@@ -9,7 +9,7 @@ from ..db.sqlite_db import SQLiteDatabase
 from ..db.base import SessionRecord
 from ..db.locks import lease_lock, lock_key_for_event_summary, make_lock_owner
 from .debouncer import Debouncer
-from ..llm_client import call_llm, extract_json
+from ..llm_client import extract_json, call_llm_cloud
 
 logger = logging.getLogger(__name__)
 
@@ -201,41 +201,82 @@ def _generate_event_summary_llm(sessions: List[SessionRecord]) -> Tuple[str, str
             }
         )
 
-    system_prompt = _get_event_summary_prompt()
-
-    user_prompt = json.dumps(
-        {
-            "total_sessions": len(sessions),
-            "sessions": sessions_data,
-        },
-        ensure_ascii=False,
-        indent=2,
-    )
-
+    # Try cloud provider first if user is logged in
     try:
-        # Use unified LLM client
-        _, response = call_llm(
-            system_prompt=system_prompt,
-            user_prompt=user_prompt,
-            provider="auto",  # Try Claude first, fallback to OpenAI
-            max_tokens=500,
-            purpose="event_summary",
-        )
-
-        if not response:
-            logger.warning("LLM returned empty response, using fallback")
-            return _fallback_event_summary(sessions)
-
-        result = extract_json(response)
-
-        title = result.get("event_title", "Untitled Event")[:100]
-        description = result.get("event_description", "")
-
-        return title, description
-
-    except Exception as e:
-        logger.warning(f"LLM event summary failed, using fallback: {e}")
-        return _fallback_event_summary(sessions)
+        from ..auth import is_logged_in
+
+        if is_logged_in():
+            logger.debug("Attempting cloud LLM for event summary")
+            # Load user custom prompt if available
+            custom_prompt = None
+            user_prompt_path = Path.home() / ".aline" / "prompts" / "event_summary.md"
+            try:
+                if user_prompt_path.exists():
+                    custom_prompt = user_prompt_path.read_text(encoding="utf-8").strip()
+            except Exception:
+                pass
+
+            _, result = call_llm_cloud(
+                task="event_summary",
+                payload={"sessions": sessions_data},
+                custom_prompt=custom_prompt,
+                silent=True,
+            )
+
+            if result:
+                title = result.get("event_title", "Untitled Event")[:100]
+                description = result.get("event_description", "")
+                logger.info(f"Cloud LLM event summary success: title={title[:50]}...")
+                return title, description
+            else:
+                # Cloud LLM failed, use fallback (local fallback disabled)
+                logger.warning("Cloud LLM event summary failed, using fallback")
+                return _fallback_event_summary(sessions)
+    except ImportError:
+        logger.debug("Auth module not available, skipping cloud LLM")
+
+    # User not logged in, use fallback (local fallback disabled)
+    logger.warning("Not logged in, cannot use cloud LLM for event summary")
+    return _fallback_event_summary(sessions)
+
+    # =========================================================================
+    # LOCAL LLM FALLBACK DISABLED - Code kept for reference
+    # =========================================================================
+    # system_prompt = _get_event_summary_prompt()
+    #
+    # user_prompt = json.dumps(
+    #     {
+    #         "total_sessions": len(sessions),
+    #         "sessions": sessions_data,
+    #     },
+    #     ensure_ascii=False,
+    #     indent=2,
+    # )
+    #
+    # try:
+    #     # Use unified LLM client
+    #     _, response = call_llm(
+    #         system_prompt=system_prompt,
+    #         user_prompt=user_prompt,
+    #         provider="auto",  # Try Claude first, fallback to OpenAI
+    #         max_tokens=500,
+    #         purpose="event_summary",
+    #     )
+    #
+    #     if not response:
+    #         logger.warning("LLM returned empty response, using fallback")
+    #         return _fallback_event_summary(sessions)
+    #
+    #     result = extract_json(response)
+    #
+    #     title = result.get("event_title", "Untitled Event")[:100]
+    #     description = result.get("event_description", "")
+    #
+    #     return title, description
+    #
+    # except Exception as e:
+    #     logger.warning(f"LLM event summary failed, using fallback: {e}")
+    #     return _fallback_event_summary(sessions)
 
 
 def _fallback_event_summary(sessions: List[SessionRecord]) -> Tuple[str, str]:

realign/events/session_summarizer.py

@@ -10,7 +10,7 @@ from typing import List, Tuple, Optional
 from ..db.sqlite_db import SQLiteDatabase
 from ..db.base import TurnRecord
 from ..db.locks import lease_lock, lock_key_for_session_summary, make_lock_owner
-from ..llm_client import call_llm, extract_json
+from ..llm_client import extract_json, call_llm_cloud
 
 logger = logging.getLogger(__name__)
 
@@ -267,41 +267,82 @@ def _generate_session_summary_llm(turns: List[TurnRecord]) -> Tuple[str, str]:
             }
         )
 
-    system_prompt = _get_session_summary_prompt()
-
-    user_prompt = json.dumps(
-        {
-            "total_turns": len(turns),
-            "turns": turns_data,
-        },
-        ensure_ascii=False,
-        indent=2,
-    )
-
+    # Try cloud provider first if user is logged in
     try:
-        # Use unified LLM client
-        _, response = call_llm(
-            system_prompt=system_prompt,
-            user_prompt=user_prompt,
-            provider="auto",  # Try Claude first, fallback to OpenAI
-            max_tokens=500,
-            purpose="session_summary",
-        )
-
-        if not response:
-            logger.warning("LLM returned empty response, using fallback")
-            return _fallback_summary(turns)
-
-        result = extract_json(response)
+        from ..auth import is_logged_in
 
-        title = result.get("session_title", "Untitled Session")[:80]
-        summary = result.get("session_summary", "")
+        if is_logged_in():
+            logger.debug("Attempting cloud LLM for session summary")
+            # Load user custom prompt if available
+            custom_prompt = None
+            user_prompt_path = Path.home() / ".aline" / "prompts" / "session_summary.md"
+            try:
+                if user_prompt_path.exists():
+                    custom_prompt = user_prompt_path.read_text(encoding="utf-8").strip()
+            except Exception:
+                pass
 
-        return title, summary
+            _, result = call_llm_cloud(
+                task="session_summary",
+                payload={"turns": turns_data},
+                custom_prompt=custom_prompt,
+                silent=True,
+            )
 
-    except Exception as e:
-        logger.warning(f"LLM session summary failed, using fallback: {e}")
-        return _fallback_summary(turns)
+            if result:
+                title = result.get("session_title", "Untitled Session")[:80]
+                summary = result.get("session_summary", "")
+                logger.info(f"Cloud LLM session summary success: title={title[:50]}...")
+                return title, summary
+            else:
+                # Cloud LLM failed, use fallback (local fallback disabled)
+                logger.warning("Cloud LLM session summary failed, using fallback")
+                return _fallback_summary(turns)
+    except ImportError:
+        logger.debug("Auth module not available, skipping cloud LLM")
+
+    # User not logged in, use fallback (local fallback disabled)
+    logger.warning("Not logged in, cannot use cloud LLM for session summary")
+    return _fallback_summary(turns)
+
+    # =========================================================================
+    # LOCAL LLM FALLBACK DISABLED - Code kept for reference
+    # =========================================================================
+    # system_prompt = _get_session_summary_prompt()
+    #
+    # user_prompt = json.dumps(
+    #     {
+    #         "total_turns": len(turns),
+    #         "turns": turns_data,
+    #     },
+    #     ensure_ascii=False,
+    #     indent=2,
+    # )
+    #
+    # try:
+    #     # Use unified LLM client
+    #     _, response = call_llm(
+    #         system_prompt=system_prompt,
+    #         user_prompt=user_prompt,
+    #         provider="auto",  # Try Claude first, fallback to OpenAI
+    #         max_tokens=500,
+    #         purpose="session_summary",
+    #     )
+    #
+    #     if not response:
+    #         logger.warning("LLM returned empty response, using fallback")
+    #         return _fallback_summary(turns)
+    #
+    #     result = extract_json(response)
+    #
+    #     title = result.get("session_title", "Untitled Session")[:80]
+    #     summary = result.get("session_summary", "")
+    #
+    #     return title, summary
+    #
+    # except Exception as e:
+    #     logger.warning(f"LLM session summary failed, using fallback: {e}")
+    #     return _fallback_summary(turns)
 
 
 def _fallback_summary(turns: List[TurnRecord]) -> Tuple[str, str]: