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

realign/dashboard/widgets/events_table.py

@@ -1,5 +1,11 @@
 """Events Table Widget with keyboard pagination."""
 
+import contextlib
+import io
+import json
+import os
+import shutil
+import subprocess
 from datetime import datetime
 from typing import Optional, Set
 from urllib.parse import urlparse
@@ -7,7 +13,7 @@ from urllib.parse import urlparse
 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 EventsListTable(OpenableDataTable):
         self.owner.apply_mouse_selection(row_index, shift=event.shift, meta=event.meta)
 
 
-class EventsTable(Container, can_focus=True):
+class EventsTable(Container):
     """Table displaying events with keyboard pagination support."""
 
     DEFAULT_CSS = """
@@ -54,26 +60,14 @@ class EventsTable(Container, can_focus=True):
         overflow: hidden;
     }
 
-    EventsTable:focus {
-        border: solid $accent;
-    }
-
-    EventsTable .summary-section {
+    EventsTable .action-section {
         height: auto;
         margin-bottom: 1;
-        padding: 1;
-        background: $surface-darken-1;
-        border: solid $primary-darken-2;
-    }
-
-    EventsTable .summary-section Static {
-        width: 1fr;
-        height: auto;
     }
 
-    EventsTable .summary-section Button {
-        width: 12;
-        margin-left: 1;
+    EventsTable .action-section Button {
+        width: auto;
+        margin-bottom: 1;
     }
 
     EventsTable .section-header {
@@ -83,13 +77,15 @@ class EventsTable(Container, can_focus=True):
 
     EventsTable .table-container {
         height: auto;
-        overflow: hidden;
+        overflow-x: auto;
+        overflow-y: hidden;
     }
 
     EventsTable DataTable {
         height: auto;
         max-height: 100%;
-        overflow: hidden;
+        overflow-x: auto;
+        overflow-y: hidden;
     }
 
     EventsTable .pagination-info {
@@ -98,6 +94,12 @@ class EventsTable(Container, can_focus=True):
         color: $text-muted;
         text-align: center;
     }
+
+    EventsTable .stats-info {
+        height: 1;
+        color: $text-muted;
+        text-align: center;
+    }
     """
 
     # Reactive properties
@@ -108,25 +110,42 @@ class EventsTable(Container, can_focus=True):
     def __init__(self) -> None:
         super().__init__()
         self._events: list = []
+        self._events_by_id: dict = {}  # Index events by id for quick lookup
         self._total_events: int = 0
         self._selected_event_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 events table layout."""
-        with Horizontal(classes="summary-section"):
-            yield Static(id="events-summary-text")
-            yield Button("Load ctx (l)", id="load-context-btn", variant="primary")
-            yield Button("Import (y)", id="share-import-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 events to others",
+                id="share-event-btn",
+                variant="primary",
+                disabled=True,
+            )
+            yield Button(
+                "Import context from others",
+                id="share-import-btn",
+                variant="primary",
+            )
         yield Static(id="section-header", classes="section-header")
         with Container(classes="table-container"):
             yield EventsListTable(id="events-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."""
@@ -170,7 +189,9 @@ class EventsTable(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 != "events-table":
             return
 
@@ -190,7 +211,13 @@ class EventsTable(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("#", "Event ID", "Title", "Type", "Sessions", "Share", "Created")
+        table.add_column("#", key="index", width=4)
+        table.add_column("Title", key="title")  # Auto width for full title
+        table.add_column("Share", key="share", width=12)
+        table.add_column("Type", key="type", width=8)
+        table.add_column("Sessions", key="sessions", width=8)
+        table.add_column("Event ID", key="event_id", width=12)
+        table.add_column("Created", key="created", width=10)
         table.cursor_type = "row"
 
     def get_selected_event_ids(self) -> list[str]:
@@ -206,7 +233,9 @@ class EventsTable(Container, can_focus=True):
         if table.row_count == 0:
             return
         try:
-            event_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+            event_id = str(
+                table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+            )
         except Exception:
             return
 
@@ -255,19 +284,28 @@ class EventsTable(Container, can_focus=True):
                 self._selected_event_ids.update(ids_in_range)
             else:
                 self._selected_event_ids = set(ids_in_range)
-        elif meta:
+        else:
+            # Toggle selection on click (no modifier keys needed)
             if clicked_id in self._selected_event_ids:
                 self._selected_event_ids.remove(clicked_id)
             else:
                 self._selected_event_ids.add(clicked_id)
-        else:
-            self._selected_event_ids = {clicked_id}
 
         self._selection_anchor_row = row_index
         self._refresh_checkboxes_only()
 
     def _checkbox_cell(self, event_id: str) -> str:
-        return "[green]☑[/green]" if event_id in self._selected_event_ids else "☐"
+        return (
+            "[bold green]●[/bold green]"
+            if event_id in self._selected_event_ids
+            else "○"
+        )
+
+    def _format_cell(self, value: str, event_id: str) -> str:
+        """Format cell value with bold if selected."""
+        if event_id in self._selected_event_ids:
+            return f"[bold]{value}[/bold]"
+        return value
 
     def _refresh_checkboxes_only(self) -> None:
         table = self.query_one("#events-table", DataTable)
@@ -282,20 +320,49 @@ class EventsTable(Container, can_focus=True):
                 continue
             if not eid:
                 continue
+            event = self._events_by_id.get(eid)
+            if not event:
+                continue
             try:
+                # Update all cells in the row with proper formatting
+                share_id = event.get("share_id") or "-"
                 table.update_cell(eid, "sel", self._checkbox_cell(eid))
+                table.update_cell(
+                    eid, "index", self._format_cell(str(event["index"]), eid)
+                )
+                table.update_cell(eid, "title", self._format_cell(event["title"], eid))
+                table.update_cell(eid, "share", self._format_cell(share_id, eid))
+                table.update_cell(eid, "type", self._format_cell(event["type"], eid))
+                table.update_cell(
+                    eid, "sessions", self._format_cell(str(event["sessions"]), eid)
+                )
+                table.update_cell(
+                    eid, "event_id", self._format_cell(event["short_id"], eid)
+                )
+                table.update_cell(
+                    eid, "created", self._format_cell(event["created"], eid)
+                )
             except Exception:
                 continue
 
         self._update_summary_widget()
 
     def _update_summary_widget(self) -> None:
-        summary_widget = self.query_one("#events-summary-text", Static)
-        summary_text = f"[bold]Total Events:[/bold] {self._total_events}"
+        # Update stats at the bottom
+        stats_widget = self.query_one("#stats-info", Static)
         selected_count = len(self._selected_event_ids)
+
+        stats_parts = [f"Total: {self._total_events}"]
         if selected_count:
-            summary_text += f"  |  [bold]Selected:[/bold] {selected_count}"
-        summary_widget.update(summary_text)
+            stats_parts.append(f"Selected: {selected_count}")
+
+        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-event-btn", Button)
+        share_btn.disabled = selected_count == 0
 
     def _sync_to_available_height(self) -> None:
         """Recalculate rows per page and reload if the page size changed."""
@@ -342,6 +409,9 @@ class EventsTable(Container, can_focus=True):
             if callable(action):
                 await action()
             return
+        if button_id == "share-event-btn":
+            self._start_share_export()
+            return
 
     def action_share_import(self) -> None:
         from ..screens import ShareImportScreen
@@ -402,6 +472,15 @@ class EventsTable(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
 
@@ -424,13 +503,182 @@ class EventsTable(Container, can_focus=True):
                 self._total_events = 0
             try:
                 self._events = list(result.get("events") or [])
+                self._events_by_id = {e["id"]: e for e in self._events}
             except Exception:
                 self._events = []
+                self._events_by_id = {}
             self._update_display()
 
         if self._pending_refresh_snapshot is not None:
             self.refresh_data()
 
+    def _start_share_export(self) -> None:
+        """Export selected events as share links."""
+        selected_ids = list(self._selected_event_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:
+            # Export the first selected event (for now, support single event)
+            event_id = selected_ids[0]
+
+            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 = {
+                "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 = {}
+
+        exit_code = int(result.get("exit_code", 1))
+
+        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()
+                db_event = db.get_event_by_id(event_id)
+                if db_event:
+                    if not share_link:
+                        share_link = getattr(db_event, "share_url", None)
+                    if not slack_message:
+                        slack_message = getattr(db_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)
+
+        # Refresh to show updated share info
+        self.refresh_data()
+
     def _extract_share_id(self, share_url: Optional[str]) -> str:
         if not share_url:
             return ""
@@ -555,60 +803,56 @@ class EventsTable(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]Events[/bold] [dim]({mode})[/dim]")
+        header_widget.update("[bold]Events[/bold]")
 
         # Update table
         table = self.query_one("#events-table", DataTable)
         selected_event_id = None
         try:
             if table.row_count > 0:
-                selected_event_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+                selected_event_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
         except Exception:
             selected_event_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 event in self._events:
+            eid = event["id"]
+            share_id = event.get("share_id") or "-"
             title = event["title"]
-            if self.wrap_mode:
-                title_cell = title
-            else:
-                title_cell = title[:50] + "..." if len(title) > 50 else title
 
-            share_url = event.get("share_url") or ""
-            share_id = event.get("share_id") or ""
-            if self.wrap_mode:
-                share_cell = str(share_url) if share_url else "-"
-            else:
-                share_cell = share_id or "-"
+            if not self.wrap_mode and len(title) > 60:
+                title = title[:57] + "..."
+
+            share_val = share_id
+            if self.wrap_mode and event.get("share_url"):
+                share_val = event.get("share_url")
 
+            # Column order: ✓, #, Title, Share, Type, Sessions, Event ID, Created
             table.add_row(
-                self._checkbox_cell(event["id"]),
-                str(event["index"]),
-                event["short_id"],
-                title_cell,
-                event["type"],
-                str(event["sessions"]),
-                share_cell,
-                event["created"],
-                key=event["id"],
+                self._checkbox_cell(eid),
+                self._format_cell(str(event["index"]), eid),
+                self._format_cell(title, eid),
+                self._format_cell(share_val, eid),
+                self._format_cell(event["type"], eid),
+                self._format_cell(str(event["sessions"]), eid),
+                self._format_cell(event["short_id"], eid),
+                self._format_cell(event["created"], eid),
+                key=eid,
             )
 
         if table.row_count > 0:
             if selected_event_id:
                 try:
-                    table.cursor_coordinate = (table.get_row_index(selected_event_id), 0)
+                    table.cursor_coordinate = (
+                        table.get_row_index(selected_event_id),
+                        0,
+                    )
                 except Exception:
                     table.cursor_coordinate = (0, 0)
             else:
@@ -618,7 +862,7 @@ class EventsTable(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_events} total)  │  (p) prev  (n) next  (s) wrap[/dim]"
+            f"[dim]Page {self.current_page}/{total_pages} ({self._total_events} total)  │  (p) prev  (n) next[/dim]"
         )
 
     def _shorten_id(self, event_id: str) -> str:

realign/dashboard/widgets/header.py

@@ -23,6 +23,7 @@ class AlineHeader(Static):
         """Get the Aline version."""
         try:
             from importlib.metadata import version
+
             return version("aline-ai")
         except Exception:
             return "0.4.1"
@@ -39,5 +40,5 @@ class AlineHeader(Static):
         line3 = " ███████║██║     ██║██╔██╗ ██║█████╗  "
         line4 = " ██╔══██║██║     ██║██║╚██╗██║██╔══╝  "
         line5 = " ██║  ██║███████╗██║██║ ╚████║███████╗"
-        info = f"[dim]v{self._version} │ Shared AI Memory[/dim]"
+        info = f"[dim]v{self._version} │ Shared Agent Context[/dim]"
         return f"{line1}\n{line2}\n{line3}\n{line4}\n{line5}  {info}"

realign/dashboard/widgets/search_panel.py

@@ -115,7 +115,9 @@ class SearchPanel(Static):
             session_id = result.get("session_id") or ""
             turn_id = result.get("turn_id") or ""
             if session_id:
-                self.app.push_screen(SessionDetailScreen(session_id, initial_turn_id=turn_id or None))
+                self.app.push_screen(
+                    SessionDetailScreen(session_id, initial_turn_id=turn_id or None)
+                )
             return
 
     def on_input_submitted(self, event: Input.Submitted) -> None:
@@ -156,30 +158,32 @@ class SearchPanel(Static):
 
             # Search based on type
             if self._search_type in ("all", "event"):
-                events = db.search_events(
-                    self._query, limit=20, use_regex=True, ignore_case=True
-                )
+                events = db.search_events(self._query, limit=20, use_regex=True, ignore_case=True)
                 for event in events:
-                    self._results.append({
-                        "type": "Event",
-                        "id": self._shorten_id(event.id),
-                        "full_id": event.id,
-                        "title": (event.title or "(no title)")[:60],
-                        "context": event.event_type or "-",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Event",
+                            "id": self._shorten_id(event.id),
+                            "full_id": event.id,
+                            "title": (event.title or "(no title)")[:60],
+                            "context": event.event_type or "-",
+                        }
+                    )
 
             if self._search_type in ("all", "session"):
                 sessions = db.search_sessions(
                     self._query, limit=20, use_regex=True, ignore_case=True
                 )
                 for session in sessions:
-                    self._results.append({
-                        "type": "Session",
-                        "id": self._shorten_id(session.id),
-                        "full_id": session.id,
-                        "title": (session.session_title or "(no title)")[:60],
-                        "context": session.session_type or "-",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Session",
+                            "id": self._shorten_id(session.id),
+                            "full_id": session.id,
+                            "title": (session.session_title or "(no title)")[:60],
+                            "context": session.session_type or "-",
+                        }
+                    )
 
             if self._search_type in ("all", "turn"):
                 turns = db.search_conversations(
@@ -188,14 +192,18 @@ class SearchPanel(Static):
                 for turn in turns:
                     session_id = turn.get("session_id", "")
                     turn_id = turn.get("turn_id", "")
-                    self._results.append({
-                        "type": "Turn",
-                        "id": self._shorten_id(turn_id),
-                        "turn_id": turn_id,
-                        "session_id": session_id,
-                        "title": (turn.get("title") or turn.get("summary") or "(no title)")[:60],
-                        "context": f"{self._shorten_id(session_id)} • Turn #{turn.get('turn_number', '-')}",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Turn",
+                            "id": self._shorten_id(turn_id),
+                            "turn_id": turn_id,
+                            "session_id": session_id,
+                            "title": (turn.get("title") or turn.get("summary") or "(no title)")[
+                                :60
+                            ],
+                            "context": f"{self._shorten_id(session_id)} • Turn #{turn.get('turn_number', '-')}",
+                        }
+                    )
 
             self._update_display()
 
@@ -232,7 +240,9 @@ class SearchPanel(Static):
 
             summary_text = f"Found {len(self._results)} results for '{self._query}'"
             if self._search_type == "all":
-                summary_text += f" (Events: {event_count}, Sessions: {session_count}, Turns: {turn_count})"
+                summary_text += (
+                    f" (Events: {event_count}, Sessions: {session_count}, Turns: {turn_count})"
+                )
 
             summary.update(f"[dim]{summary_text}[/dim]")
         else: