aline-ai 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

realign/dashboard/widgets/sessions_table.py

@@ -1,5 +1,11 @@
 """Sessions Table Widget with keyboard pagination."""
 
+import contextlib
+import io
+import json
+import os
+import shutil
+import subprocess
 from datetime import datetime
 from pathlib import Path
 from typing import List, Optional, Set
@@ -7,7 +13,7 @@ from typing import List, Optional, Set
 from textual import events
 from textual.app import ComposeResult
 from textual.binding import Binding
-from textual.containers import Container, Horizontal
+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
@@ -44,7 +50,7 @@ class SessionsListTable(OpenableDataTable):
         self.owner.apply_mouse_selection(row_index, shift=event.shift, meta=event.meta)
 
 
-class SessionsTable(Container, can_focus=True):
+class SessionsTable(Container):
     """Table displaying sessions with keyboard pagination support."""
 
     DEFAULT_CSS = """
@@ -54,26 +60,14 @@ class SessionsTable(Container, can_focus=True):
         overflow: hidden;
     }
 
-    SessionsTable:focus {
-        border: solid $accent;
-    }
-
-    SessionsTable .summary-section {
+    SessionsTable .action-section {
         height: auto;
         margin-bottom: 1;
-        padding: 1;
-        background: $surface-darken-1;
-        border: solid $primary-darken-2;
-    }
-
-    SessionsTable .summary-section Static {
-        width: 1fr;
-        height: auto;
     }
 
-    SessionsTable .summary-section Button {
-        width: 12;
-        margin-left: 1;
+    SessionsTable .action-section Button {
+        width: auto;
+        margin-bottom: 1;
     }
 
     SessionsTable .section-header {
@@ -83,13 +77,15 @@ class SessionsTable(Container, can_focus=True):
 
     SessionsTable .table-container {
         height: auto;
-        overflow: hidden;
+        overflow-x: auto;
+        overflow-y: hidden;
     }
 
     SessionsTable DataTable {
         height: auto;
         max-height: 100%;
-        overflow: hidden;
+        overflow-x: auto;
+        overflow-y: hidden;
     }
 
     SessionsTable .pagination-info {
@@ -98,6 +94,12 @@ class SessionsTable(Container, can_focus=True):
         color: $text-muted;
         text-align: center;
     }
+
+    SessionsTable .stats-info {
+        height: 1;
+        color: $text-muted;
+        text-align: center;
+    }
     """
 
     # Reactive properties
@@ -108,25 +110,38 @@ class SessionsTable(Container, can_focus=True):
     def __init__(self) -> None:
         super().__init__()
         self._sessions: list = []
+        self._sessions_by_id: dict = {}  # Index sessions by id for quick lookup
         self._total_sessions: int = 0
         self._stats: dict = {}
         self._selected_session_ids: Set[str] = set()
         self._selection_anchor_row: Optional[int] = None
         self._last_wrap_mode: bool = bool(self.wrap_mode)
         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
 
     def compose(self) -> ComposeResult:
         """Compose the sessions table layout."""
-        with Horizontal(classes="summary-section"):
-            yield Static(id="sessions-summary")
-            yield Button("Load ctx (l)", id="load-context-btn", variant="primary")
+        with Vertical(classes="action-section"):
+            yield Button(
+                "Load selected context to current agent",
+                id="load-context-btn",
+                variant="primary",
+                disabled=True,
+            )
+            yield Button(
+                "Share selected contexts to others",
+                id="share-context-btn",
+                variant="primary",
+                disabled=True,
+            )
         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:
         """Set up the table on mount."""
@@ -171,7 +186,9 @@ class SessionsTable(Container, can_focus=True):
         except Exception:
             pass
 
-    def on_openable_data_table_row_activated(self, event: OpenableDataTable.RowActivated) -> None:
+    def on_openable_data_table_row_activated(
+        self, event: OpenableDataTable.RowActivated
+    ) -> None:
         if event.data_table.id != "sessions-table":
             return
 
@@ -191,7 +208,13 @@ class SessionsTable(Container, can_focus=True):
     def _setup_table_columns(self, table: DataTable) -> None:
         table.clear(columns=True)
         table.add_column("✓", key="sel", width=2)
-        table.add_columns("#", "Session ID", "Source", "Project", "Turns", "Title", "Last Activity")
+        table.add_column("#", key="index", width=3)
+        table.add_column("Title", key="title")  # Auto width for full title
+        table.add_column("Project", key="project", width=15)
+        table.add_column("Source", key="source", width=10)
+        table.add_column("Turns", key="turns", width=6)
+        table.add_column("Session ID", key="session_id", width=20)
+        table.add_column("Last Activity", key="last_activity", width=12)
         table.cursor_type = "row"
 
     def _sync_to_available_height(self) -> None:
@@ -220,7 +243,9 @@ class SessionsTable(Container, can_focus=True):
         if table.row_count == 0:
             return
         try:
-            session_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+            session_id = str(
+                table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+            )
         except Exception:
             return
 
@@ -269,19 +294,28 @@ class SessionsTable(Container, can_focus=True):
                 self._selected_session_ids.update(ids_in_range)
             else:
                 self._selected_session_ids = set(ids_in_range)
-        elif meta:
+        else:
+            # Toggle selection on click (no modifier keys needed)
             if clicked_id in self._selected_session_ids:
                 self._selected_session_ids.remove(clicked_id)
             else:
                 self._selected_session_ids.add(clicked_id)
-        else:
-            self._selected_session_ids = {clicked_id}
 
         self._selection_anchor_row = row_index
         self._refresh_checkboxes_only()
 
     def _checkbox_cell(self, session_id: str) -> str:
-        return "[green]☑[/green]" if session_id in self._selected_session_ids else "☐"
+        return (
+            "[bold green]●[/bold green]"
+            if session_id in self._selected_session_ids
+            else "○"
+        )
+
+    def _format_cell(self, value: str, session_id: str) -> str:
+        """Format cell value with bold if selected."""
+        if session_id in self._selected_session_ids:
+            return f"[bold]{value}[/bold]"
+        return value
 
     def _refresh_checkboxes_only(self) -> None:
         table = self.query_one("#sessions-table", DataTable)
@@ -296,40 +330,80 @@ class SessionsTable(Container, can_focus=True):
                 continue
             if not sid:
                 continue
+            session = self._sessions_by_id.get(sid)
+            if not session:
+                continue
             try:
+                # Update all cells in the row with proper formatting
                 table.update_cell(sid, "sel", self._checkbox_cell(sid))
+                table.update_cell(
+                    sid, "index", self._format_cell(str(session["index"]), sid)
+                )
+                table.update_cell(
+                    sid, "title", self._format_cell(session["title"], sid)
+                )
+                table.update_cell(
+                    sid, "project", self._format_cell(session["project"], sid)
+                )
+                table.update_cell(
+                    sid, "source", self._format_cell(session["source"], sid)
+                )
+                table.update_cell(
+                    sid, "turns", self._format_cell(str(session["turns"]), sid)
+                )
+                table.update_cell(
+                    sid, "session_id", self._format_cell(session["short_id"], sid)
+                )
+                table.update_cell(
+                    sid,
+                    "last_activity",
+                    self._format_cell(session["last_activity"], sid),
+                )
             except Exception:
                 continue
 
         self._update_summary_widget()
 
     def _update_summary_widget(self) -> None:
-        summary_widget = self.query_one("#sessions-summary", Static)
+        # Update stats at the bottom
+        stats_widget = self.query_one("#stats-info", Static)
         total = self._stats.get("total", 0)
         claude = self._stats.get("claude", 0)
         codex = self._stats.get("codex", 0)
         gemini = self._stats.get("gemini", 0)
 
-        summary_text = f"[bold]Total Sessions:[/bold] {total}"
+        stats_parts = [f"Total: {total}"]
         if claude > 0:
-            summary_text += f"  |  [cyan]Claude:[/cyan] {claude}"
+            stats_parts.append(f"Claude: {claude}")
         if codex > 0:
-            summary_text += f"  |  [magenta]Codex:[/magenta] {codex}"
+            stats_parts.append(f"Codex: {codex}")
         if gemini > 0:
-            summary_text += f"  |  [yellow]Gemini:[/yellow] {gemini}"
+            stats_parts.append(f"Gemini: {gemini}")
 
         selected_count = len(self._selected_session_ids)
         if selected_count:
-            summary_text += f"  |  [bold]Selected:[/bold] {selected_count}"
+            stats_parts.append(f"Selected: {selected_count}")
 
-        summary_widget.update(summary_text)
+        stats_widget.update(f"[dim]{' | '.join(stats_parts)}[/dim]")
+
+        # Enable/disable buttons based on selection
+        load_btn = self.query_one("#load-context-btn", Button)
+        load_btn.disabled = selected_count == 0
+        share_btn = self.query_one("#share-context-btn", Button)
+        share_btn.disabled = selected_count == 0
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
-        if (event.button.id or "") != "load-context-btn":
+        button_id = event.button.id or ""
+
+        if button_id == "load-context-btn":
+            action = getattr(self.app, "action_load_context", None)
+            if callable(action):
+                await action()
+            return
+
+        if button_id == "share-context-btn":
+            self._start_share_export()
             return
-        action = getattr(self.app, "action_load_context", None)
-        if callable(action):
-            await action()
 
     def _calculate_rows_per_page(self) -> None:
         """Calculate rows per page based on available height."""
@@ -407,6 +481,15 @@ class SessionsTable(Container, can_focus=True):
         self.refresh_data()
 
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
+        # Handle share export worker
+        if (
+            self._share_export_worker is not None
+            and event.worker is self._share_export_worker
+        ):
+            self._on_share_export_worker_changed(event)
+            return
+
+        # Handle refresh worker
         if self._refresh_worker is None or event.worker is not self._refresh_worker:
             return
 
@@ -434,13 +517,243 @@ class SessionsTable(Container, can_focus=True):
                 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:
             self.refresh_data()
 
+    def _start_share_export(self) -> None:
+        """Generate an event from selected sessions and export as share link."""
+        selected_ids = list(self._selected_session_ids)
+        if not selected_ids:
+            return
+
+        if (
+            self._share_export_worker is not None
+            and self._share_export_worker.state
+            in (
+                WorkerState.PENDING,
+                WorkerState.RUNNING,
+            )
+        ):
+            return
+
+        def work() -> dict:
+            # Step 1: Generate event from selected sessions
+            session_selector = ",".join(selected_ids)
+            stdout_gen = io.StringIO()
+            stderr_gen = io.StringIO()
+
+            with (
+                contextlib.redirect_stdout(stdout_gen),
+                contextlib.redirect_stderr(stderr_gen),
+            ):
+                from ...commands.watcher import watcher_event_generate_command
+
+                gen_exit_code = watcher_event_generate_command(
+                    session_selector=session_selector,
+                    show_sessions=False,
+                )
+
+            if gen_exit_code != 0:
+                return {
+                    "step": "generate",
+                    "exit_code": gen_exit_code,
+                    "stderr": stderr_gen.getvalue().strip(),
+                }
+
+            # Extract event_id from output
+            gen_output = stdout_gen.getvalue().strip()
+            event_id = None
+            for line in gen_output.split("\n"):
+                if line.startswith("Event ID:"):
+                    event_id = line.split(":", 1)[1].strip()
+                    break
+
+            if not event_id:
+                # Try to find the most recent event
+                try:
+                    from ...db import get_database
+
+                    db = get_database()
+                    conn = db._get_connection()
+                    row = conn.execute(
+                        "SELECT id FROM events ORDER BY created_at DESC LIMIT 1"
+                    ).fetchone()
+                    if row:
+                        event_id = row[0]
+                except Exception:
+                    pass
+
+            if not event_id:
+                return {
+                    "step": "generate",
+                    "exit_code": 1,
+                    "stderr": "Could not determine event ID",
+                }
+
+            # Step 2: Export the event as a share link
+            stdout_exp = io.StringIO()
+            stderr_exp = io.StringIO()
+
+            with (
+                contextlib.redirect_stdout(stdout_exp),
+                contextlib.redirect_stderr(stderr_exp),
+            ):
+                from ...commands import export_shares
+
+                exp_exit_code = export_shares.export_shares_interactive_command(
+                    indices=event_id,
+                    password=None,
+                    enable_preview=False,
+                    json_output=True,
+                    compact=True,
+                )
+
+            exp_output = stdout_exp.getvalue().strip()
+            result: dict = {
+                "step": "export",
+                "exit_code": exp_exit_code,
+                "output": exp_output,
+                "stderr": stderr_exp.getvalue().strip(),
+                "event_id": event_id,
+            }
+
+            if exp_output:
+                # Try to extract JSON from output (may contain other text)
+                try:
+                    result["json"] = json.loads(exp_output)
+                except Exception:
+                    # Try to find JSON object in output
+                    json_start = exp_output.find("{")
+                    json_end = exp_output.rfind("}") + 1
+                    if json_start >= 0 and json_end > json_start:
+                        try:
+                            result["json"] = json.loads(exp_output[json_start:json_end])
+                        except Exception:
+                            result["json"] = None
+                    else:
+                        result["json"] = None
+            else:
+                result["json"] = None
+
+            return result
+
+        self.app.notify("Creating share link...", title="Share", timeout=2)
+        self._share_export_worker = self.run_worker(
+            work, thread=True, exit_on_error=False
+        )
+
+    def _on_share_export_worker_changed(self, event: Worker.StateChanged) -> None:
+        """Handle share export worker state changes."""
+        if event.state == WorkerState.ERROR:
+            err = (
+                self._share_export_worker.error
+                if self._share_export_worker
+                else "Unknown error"
+            )
+            self.app.notify(
+                f"Share export failed: {err}", title="Share", severity="error"
+            )
+            return
+
+        if event.state != WorkerState.SUCCESS:
+            return
+
+        result = self._share_export_worker.result if self._share_export_worker else {}
+        if not result:
+            result = {}
+
+        step = result.get("step", "")
+        exit_code = int(result.get("exit_code", 1))
+
+        if step == "generate" and exit_code != 0:
+            stderr = result.get("stderr", "")
+            self.app.notify(
+                f"Failed to generate event: {stderr}"
+                if stderr
+                else "Failed to generate event",
+                title="Share",
+                severity="error",
+            )
+            return
+
+        if exit_code != 0:
+            stderr = result.get("stderr", "")
+            self.app.notify(
+                f"Share export failed: {stderr}" if stderr else "Share export failed",
+                title="Share",
+                severity="error",
+            )
+            return
+
+        payload = result.get("json") or {}
+        share_link = payload.get("share_link") or payload.get("share_url")
+        slack_message = (
+            payload.get("slack_message") if isinstance(payload, dict) else None
+        )
+        event_id = result.get("event_id")
+
+        # Try to fetch share_link and slack_message from database
+        if event_id:
+            try:
+                from ...db import get_database
+
+                db = get_database()
+                event = db.get_event_by_id(event_id)
+                if event:
+                    if not share_link:
+                        share_link = getattr(event, "share_url", None)
+                    if not slack_message:
+                        slack_message = getattr(event, "slack_message", None)
+            except Exception:
+                pass
+
+        if not share_link:
+            self.app.notify(
+                "Share export completed but no link generated",
+                title="Share",
+                severity="warning",
+            )
+            return
+
+        # Build copy text
+        if slack_message:
+            copy_text = str(slack_message) + "\n\n" + str(share_link)
+        else:
+            copy_text = str(share_link)
+
+        # Copy to clipboard
+        copied = False
+        if os.environ.get("TMUX") and shutil.which("pbcopy"):
+            try:
+                copied = (
+                    subprocess.run(
+                        ["pbcopy"],
+                        input=copy_text,
+                        text=True,
+                        capture_output=False,
+                        check=False,
+                    ).returncode
+                    == 0
+                )
+            except Exception:
+                copied = False
+
+        if not copied:
+            try:
+                self.app.copy_to_clipboard(copy_text)
+                copied = True
+            except Exception:
+                copied = False
+
+        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)."""
         total_sessions: int = 0
@@ -461,14 +774,16 @@ class SessionsTable(Container, can_focus=True):
                 total_sessions = int(row[0]) if row else 0
 
                 # Get stats
-                stats_row = conn.execute("""
+                stats_row = conn.execute(
+                    """
                     SELECT
                         COUNT(*) AS total,
                         COUNT(CASE WHEN session_type = 'claude' THEN 1 END) AS claude,
                         COUNT(CASE WHEN session_type = 'codex' THEN 1 END) AS codex,
                         COUNT(CASE WHEN session_type = 'gemini' THEN 1 END) AS gemini
                     FROM sessions
-                """).fetchone()
+                """
+                ).fetchone()
 
                 stats = {
                     "total": stats_row[0] if stats_row else 0,
@@ -479,7 +794,8 @@ class SessionsTable(Container, can_focus=True):
 
                 # Get paginated sessions
                 offset = (int(page) - 1) * int(rows_per_page)
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT
                         s.id,
                         s.session_type,
@@ -490,7 +806,9 @@ class SessionsTable(Container, can_focus=True):
                     FROM sessions s
                     ORDER BY s.last_activity_at DESC
                     LIMIT ? OFFSET ?
-                """, (int(rows_per_page), int(offset))).fetchall()
+                """,
+                    (int(rows_per_page), int(offset)),
+                ).fetchall()
 
                 for i, row in enumerate(rows):
                     session_id = row[0]
@@ -517,16 +835,18 @@ class SessionsTable(Container, can_focus=True):
                         except Exception:
                             activity_str = last_activity
 
-                    sessions.append({
-                        "index": offset + i + 1,
-                        "id": session_id,
-                        "short_id": self._shorten_session_id(session_id),
-                        "source": source,
-                        "project": project,
-                        "turns": turn_count,
-                        "title": title,
-                        "last_activity": activity_str,
-                    })
+                    sessions.append(
+                        {
+                            "index": offset + i + 1,
+                            "id": session_id,
+                            "short_id": self._shorten_session_id(session_id),
+                            "source": source,
+                            "project": project,
+                            "turns": turn_count,
+                            "title": title,
+                            "last_activity": activity_str,
+                        }
+                    )
         except Exception:
             total_sessions = 0
             stats = {}
@@ -545,55 +865,54 @@ class SessionsTable(Container, can_focus=True):
 
         # Update section header
         header_widget = self.query_one("#section-header", Static)
-        mode = "Wrap" if self.wrap_mode else "Compact"
-        header_widget.update(f"[bold]Sessions[/bold] [dim]({mode})[/dim]")
+        header_widget.update("[bold]Sessions[/bold]")
 
         # 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)
+                selected_session_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
         except Exception:
             selected_session_id = None
-        if self.wrap_mode != self._last_wrap_mode:
-            self._setup_table_columns(table)
-            self._last_wrap_mode = bool(self.wrap_mode)
-        else:
-            table.clear()
+        table.clear()
 
-        if self.wrap_mode:
-            table.styles.overflow_x = "auto"
-            table.show_horizontal_scrollbar = True
-        else:
-            table.styles.overflow_x = "hidden"
-            table.show_horizontal_scrollbar = False
+        # Always enable horizontal scrollbar
+        table.styles.overflow_x = "auto"
+        table.show_horizontal_scrollbar = True
 
         for session in self._sessions:
+            sid = session["id"]
             title = session["title"]
+            if not self.wrap_mode and len(title) > 60:
+                title = title[:57] + "..."
+
+            display_id = session["short_id"]
             if self.wrap_mode:
-                title_cell = title
-                session_id_cell = session["id"]
-            else:
-                title_cell = title[:40] + "..." if len(title) > 40 else title
-                session_id_cell = session["short_id"]
+                display_id = sid
 
+            # Column order: ✓, #, Title, Project, Source, Turns, Session ID, Last Activity
             table.add_row(
-                self._checkbox_cell(session["id"]),
-                str(session["index"]),
-                session_id_cell,
-                session["source"],
-                session["project"],
-                str(session["turns"]),
-                title_cell,
-                session["last_activity"],
-                key=session["id"],
+                self._checkbox_cell(sid),
+                self._format_cell(str(session["index"]), sid),
+                self._format_cell(title, sid),
+                self._format_cell(session["project"], sid),
+                self._format_cell(session["source"], sid),
+                self._format_cell(str(session["turns"]), sid),
+                self._format_cell(display_id, sid),
+                self._format_cell(session["last_activity"], sid),
+                key=sid,
             )
 
         if table.row_count > 0:
             if selected_session_id:
                 try:
-                    table.cursor_coordinate = (table.get_row_index(selected_session_id), 0)
+                    table.cursor_coordinate = (
+                        table.get_row_index(selected_session_id),
+                        0,
+                    )
                 except Exception:
                     table.cursor_coordinate = (0, 0)
             else:
@@ -603,7 +922,7 @@ class SessionsTable(Container, can_focus=True):
         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  (s) wrap[/dim]"
+            f"[dim]Page {self.current_page}/{total_pages} ({self._total_sessions} total)  │  (p) prev  (n) next[/dim]"
         )
 
     def _shorten_session_id(self, session_id: str) -> str: