@anastops/cli 1.0.0 → 1.2.0

package/ranger-tui/ranger_tui/widgets/metrics_panel.py

@@ -0,0 +1,121 @@
+"""
+Metrics panel widget showing session statistics.
+"""
+
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Static
+from textual.containers import Vertical
+from textual.reactive import reactive
+
+from ranger_tui.data import Session
+
+
+class MetricsPanel(Widget):
+    """Panel widget for displaying session metrics."""
+    
+    DEFAULT_CSS = """
+    MetricsPanel {
+        height: 1fr;
+        padding: 1;
+    }
+    
+    MetricsPanel .metric-row {
+        height: auto;
+        margin-bottom: 1;
+    }
+    
+    MetricsPanel .metric-label {
+        color: $text-muted;
+    }
+    
+    MetricsPanel .metric-value {
+        text-style: bold;
+    }
+    
+    MetricsPanel .metric-value-success {
+        color: $success;
+        text-style: bold;
+    }
+    
+    MetricsPanel .metric-value-warning {
+        color: $warning;
+        text-style: bold;
+    }
+    
+    MetricsPanel .metric-value-error {
+        color: $error;
+        text-style: bold;
+    }
+    """
+    
+    total_sessions = reactive(0)
+    active_sessions = reactive(0)
+    archived_sessions = reactive(0)
+    total_tasks = reactive(0)
+    completed_tasks = reactive(0)
+    failed_tasks = reactive(0)
+    total_tokens = reactive(0)
+    total_cost = reactive(0.0)
+    
+    def compose(self) -> ComposeResult:
+        """Compose the metrics panel."""
+        with Vertical():
+            yield Static("[bold]Sessions[/]", classes="section-title", markup=True)
+            yield Static("", id="sessions-metric")
+            
+            yield Static("")  # Spacer
+            
+            yield Static("[bold]Tasks[/]", classes="section-title", markup=True)
+            yield Static("", id="tasks-metric")
+            
+            yield Static("")  # Spacer
+            
+            yield Static("[bold]Usage[/]", classes="section-title", markup=True)
+            yield Static("", id="usage-metric")
+    
+    async def update_metrics(self, sessions: list[Session]) -> None:
+        """Update metrics from session list."""
+        self.total_sessions = len(sessions)
+        self.active_sessions = sum(1 for s in sessions if s.status == "active")
+        self.archived_sessions = sum(1 for s in sessions if s.status == "archived")
+        
+        self.total_tasks = sum(s.metadata.tasks_total for s in sessions)
+        self.completed_tasks = sum(s.metadata.tasks_completed for s in sessions)
+        self.failed_tasks = sum(s.metadata.tasks_failed for s in sessions)
+        
+        self.total_tokens = sum(s.metadata.total_tokens for s in sessions)
+        self.total_cost = sum(s.metadata.total_cost for s in sessions)
+        
+        await self._update_display()
+    
+    async def _update_display(self) -> None:
+        """Update the display with current metrics."""
+        # Sessions metric
+        sessions_text = (
+            f"Total: [bold]{self.total_sessions}[/]\n"
+            f"Active: [green]{self.active_sessions}[/]\n"
+            f"Archived: [dim]{self.archived_sessions}[/]"
+        )
+        self.query_one("#sessions-metric", Static).update(sessions_text)
+        
+        # Tasks metric
+        success_rate = (
+            (self.completed_tasks / self.total_tasks * 100) 
+            if self.total_tasks > 0 
+            else 0
+        )
+        tasks_text = (
+            f"Total: [bold]{self.total_tasks}[/]\n"
+            f"Completed: [green]{self.completed_tasks}[/]\n"
+            f"Failed: [red]{self.failed_tasks}[/]\n"
+            f"Success: [cyan]{success_rate:.1f}%[/]"
+        )
+        self.query_one("#tasks-metric", Static).update(tasks_text)
+        
+        # Usage metric
+        usage_text = (
+            f"Tokens: [bold]{self.total_tokens:,}[/]\n"
+            f"Cost: [yellow]${self.total_cost:.4f}[/]"
+        )
+        self.query_one("#usage-metric", Static).update(usage_text)

package/ranger-tui/ranger_tui/widgets/ranger_image.py

@@ -0,0 +1,91 @@
+"""
+RangerImage widget - Displays the ranger head image using textual-image with circular frame.
+"""
+
+from pathlib import Path
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static
+
+try:
+    from textual_image.widget import Image
+    HAS_IMAGE_SUPPORT = True
+except ImportError:
+    HAS_IMAGE_SUPPORT = False
+    Image = None
+
+
+class RangerImage(Widget):
+    """Widget to display the ranger head image with circular frame."""
+    
+    DEFAULT_CSS = """
+    RangerImage {
+        width: auto;
+        height: auto;
+        align: center middle;
+    }
+    
+    RangerImage .circle-frame {
+        width: auto;
+        height: auto;
+    }
+    
+    RangerImage .circle-top {
+        width: auto;
+        height: 1;
+        content-align: center middle;
+    }
+    
+    RangerImage .circle-middle {
+        width: auto;
+        height: auto;
+        layout: horizontal;
+    }
+    
+    RangerImage .circle-left, RangerImage .circle-right {
+        width: 1;
+        height: auto;
+        content-align: center middle;
+    }
+    
+    RangerImage .image-container {
+        width: 8;
+        height: 4;
+        margin: 0 1;
+    }
+    
+    RangerImage .circle-bottom {
+        width: auto;
+        height: 1;
+        content-align: center middle;
+    }
+    
+    RangerImage Image {
+        width: 100%;
+        height: 100%;
+    }
+    """
+    
+    def __init__(
+        self,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        
+        # Get the path to the ranger head image
+        self._image_path = Path(__file__).parent.parent / "assets" / "ranger_head.png"
+    
+    def compose(self) -> ComposeResult:
+        # Circular frame using ASCII art (Looney Tunes style) - matching theme colors
+        with Vertical(classes="circle-frame"):
+            yield Static("[#3d5c8c]╭──────────╮[/]", classes="circle-top", markup=True)
+            with Horizontal(classes="circle-middle"):
+                yield Static("[#3d5c8c]│[/]", classes="circle-left", markup=True)
+                with Vertical(classes="image-container"):
+                    if HAS_IMAGE_SUPPORT and self._image_path.exists():
+                        yield Image(self._image_path)
+                yield Static("[#3d5c8c]│[/]", classes="circle-right", markup=True)
+            yield Static("[#3d5c8c]╰──────────╯[/]", classes="circle-bottom", markup=True)

package/ranger-tui/ranger_tui/widgets/sessions_table.py

@@ -0,0 +1,191 @@
+"""
+Sessions table widget using Textual DataTable.
+"""
+
+from datetime import datetime, UTC
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import DataTable
+from textual.reactive import reactive
+
+from ranger_tui.data import Session, SessionMetadata
+
+
+class SessionsTable(Widget):
+    """Table widget for displaying sessions."""
+    
+    DEFAULT_CSS = """
+    SessionsTable {
+        height: 1fr;
+    }
+    
+    SessionsTable DataTable {
+        height: 100%;
+    }
+    """
+    
+    sessions: reactive[list[Session]] = reactive(list, init=False)
+    _selected_row_key: str | None = None
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.sessions = []
+    
+    def compose(self) -> ComposeResult:
+        """Compose the table."""
+        table = DataTable(
+            id="sessions-data-table",
+            cursor_type="row",
+            zebra_stripes=True,
+        )
+        yield table
+    
+    def on_mount(self) -> None:
+        """Set up the table columns with proportional widths."""
+        # Calculate available width based on parent container
+        try:
+            table_width = self.app.size.width - 34  # Sidebar(28) + padding(6)
+        except Exception:
+            table_width = 100
+        
+        table_width = max(table_width, 60)
+        usable_width = table_width - 6  # Column separators
+        
+        # Proportional: Status 10%, ID 14%, Objective 38%, Tasks 8%, Tokens 10%, Cost 10%, Age 10%
+        status_w = max(8, int(usable_width * 0.10))
+        id_w = max(10, int(usable_width * 0.14))
+        tasks_w = max(5, int(usable_width * 0.08))
+        tokens_w = max(6, int(usable_width * 0.10))
+        cost_w = max(6, int(usable_width * 0.10))
+        age_w = max(4, int(usable_width * 0.10))
+        objective_w = usable_width - status_w - id_w - tasks_w - tokens_w - cost_w - age_w
+        objective_w = max(15, objective_w)
+        
+        table = self.query_one(DataTable)
+        table.add_column("Status", key="status", width=status_w)
+        table.add_column("ID", key="id", width=id_w)
+        table.add_column("Objective", key="objective", width=objective_w)
+        table.add_column("Tasks", key="tasks", width=tasks_w)
+        table.add_column("Tokens", key="tokens", width=tokens_w)
+        table.add_column("Cost", key="cost", width=cost_w)
+        table.add_column("Age", key="age", width=age_w)
+    
+    async def update_sessions(self, sessions: list[Session]) -> None:
+        """Update the table with new session data."""
+        self.sessions = sessions
+        
+        table = self.query_one(DataTable)
+        
+        # Remember current selection
+        current_key = self._selected_row_key
+        
+        # Clear and repopulate
+        table.clear()
+        
+        for session in sessions:
+            status_display = self._format_status(session.status)
+            tasks_display = self._format_tasks(session.metadata)
+            tokens_display = f"{session.metadata.total_tokens:,}"
+            cost_display = f"${session.metadata.total_cost:.4f}"
+            age_display = self._format_age(session.created_at)
+            objective_display = session.objective[:38] + "..." if len(session.objective) > 40 else session.objective
+            
+            table.add_row(
+                status_display,
+                session.id,
+                objective_display,
+                tasks_display,
+                tokens_display,
+                cost_display,
+                age_display,
+                key=session.id,
+            )
+        
+        # Restore selection if possible
+        if current_key:
+            try:
+                row_index = table.get_row_index(current_key)
+                table.cursor_coordinate = (row_index, 0)
+                self._selected_row_key = current_key
+            except Exception:
+                pass
+    
+    def _format_status(self, status: str) -> str:
+        """Format status with color markup."""
+        status_colors = {
+            "active": "[green]● active[/]",
+            "completed": "[blue]✓ done[/]",
+            "archived": "[dim]◌ archived[/]",
+        }
+        return status_colors.get(status, f"[yellow]{status}[/]")
+    
+    def _format_tasks(self, metadata: SessionMetadata) -> str:
+        """Format tasks as completed/total with running indicator."""
+        total = metadata.tasks_total
+        completed = metadata.tasks_completed
+        running = metadata.tasks_running
+        
+        if running > 0:
+            # Animated spinner chars for running tasks
+            spinner_frames = ["◐", "◓", "◑", "◒"]
+            frame_idx = int(datetime.now(UTC).timestamp() * 2) % len(spinner_frames)
+            spinner = spinner_frames[frame_idx]
+            return f"[cyan]{spinner}[/] {completed}/{total}"
+        elif total == 0:
+            return "[dim]0/0[/]"
+        elif completed == total:
+            return f"[green]✓[/] {completed}/{total}"
+        else:
+            return f"{completed}/{total}"
+    
+    def _format_age(self, created_at: datetime) -> str:
+        """Format age in human-readable form."""
+        # Handle naive datetimes from MongoDB (assume UTC)
+        if created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=UTC)
+        age = datetime.now(UTC) - created_at
+        
+        if age.total_seconds() < 60:
+            return f"{int(age.total_seconds())}s"
+        elif age.total_seconds() < 3600:
+            return f"{int(age.total_seconds() / 60)}m"
+        elif age.total_seconds() < 86400:
+            return f"{int(age.total_seconds() / 3600)}h"
+        else:
+            return f"{int(age.total_seconds() / 86400)}d"
+    
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle row selection."""
+        self._selected_row_key = str(event.row_key.value) if event.row_key else None
+    
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """Handle row highlight (cursor movement)."""
+        self._selected_row_key = str(event.row_key.value) if event.row_key else None
+    
+    def get_selected_session_id(self) -> str | None:
+        """Get the currently selected session ID."""
+        table = self.query_one(DataTable)
+        if table.cursor_row is not None:
+            row_key = table.get_row_at(table.cursor_row)
+            if row_key:
+                # Get the ID from the second column (index 1)
+                return str(table.get_cell_at((table.cursor_row, 1)))
+        return self._selected_row_key
+
+    @property
+    def row_count(self) -> int:
+        """Get the number of rows in the table."""
+        table = self.query_one(DataTable)
+        return table.row_count
+
+    @property
+    def column_count(self) -> int:
+        """Get the number of columns in the table."""
+        table = self.query_one(DataTable)
+        return len(table.columns)
+
+    @property
+    def cursor_row(self) -> int | None:
+        """Get the current cursor row."""
+        table = self.query_one(DataTable)
+        return table.cursor_row

package/ranger-tui/ranger_tui/widgets/sidebar.py

@@ -0,0 +1,91 @@
+"""
+Sidebar widget - Right panel for stats and details.
+"""
+
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+
+from ranger_tui.widgets.logo import Logo
+
+
+class Sidebar(Widget):
+    """Sidebar panel for displaying stats and details."""
+    
+    DEFAULT_CSS = """
+    Sidebar {
+        width: 28;
+        min-width: 26;
+        max-width: 32;
+        background: $panel;
+        border: round $secondary-darken-2;
+        padding: 1 2;
+        layout: vertical;
+    }
+    
+    Sidebar > .sidebar-title {
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+        dock: top;
+    }
+    
+    Sidebar > .sidebar-content {
+        color: $foreground;
+    }
+    
+    Sidebar > #spacer {
+        height: 1fr;
+    }
+
+    Sidebar > Logo {
+        margin-top: 1;
+        dock: bottom;
+    }
+    
+    Sidebar .stat-label {
+        color: $foreground-muted;
+    }
+    
+    Sidebar .stat-value {
+        color: $foreground;
+    }
+    
+    Sidebar .stat-success {
+        color: $success;
+    }
+    
+    Sidebar .stat-error {
+        color: $error;
+    }
+    
+    Sidebar .stat-warning {
+        color: $warning;
+    }
+    """
+    
+    def __init__(self, title: str = "Details", content: str = "") -> None:
+        super().__init__()
+        self._title = title
+        self._content = content
+    
+    def compose(self) -> ComposeResult:
+        yield Static(self._title, classes="sidebar-title", id="sidebar-title")
+        yield Static(self._content, classes="sidebar-content", id="sidebar-content")
+    
+    def update_title(self, title: str) -> None:
+        """Update sidebar title."""
+        self._title = title
+        try:
+            self.query_one("#sidebar-title", Static).update(title)
+        except Exception:
+            pass
+    
+    def update_content(self, content: str) -> None:
+        """Update sidebar content."""
+        self._content = content
+        try:
+            self.query_one("#sidebar-content", Static).update(content)
+        except Exception:
+            pass

package/ranger-tui/ranger_tui/widgets/tasks_table.py

@@ -0,0 +1,189 @@
+"""
+Tasks table widget using Textual DataTable.
+"""
+
+from datetime import datetime, UTC
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import DataTable
+from textual.reactive import reactive
+
+from ranger_tui.data import Task
+from ranger_tui.theme import format_model
+
+
+class TasksTable(Widget):
+    """Table widget for displaying tasks."""
+    
+    DEFAULT_CSS = """
+    TasksTable {
+        height: 1fr;
+    }
+    
+    TasksTable DataTable {
+        height: 100%;
+    }
+    """
+    
+    tasks: reactive[list[Task]] = reactive(list, init=False)
+    _selected_row_key: str | None = None
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.tasks = []
+    
+    def compose(self) -> ComposeResult:
+        """Compose the table."""
+        table = DataTable(
+            id="tasks-data-table",
+            cursor_type="row",
+            zebra_stripes=True,
+        )
+        yield table
+    
+    def on_mount(self) -> None:
+        """Set up the table columns with proportional widths."""
+        # Calculate available width based on parent container
+        try:
+            table_width = self.app.size.width - 34  # Sidebar(28) + padding(6)
+        except Exception:
+            table_width = 100
+        
+        table_width = max(table_width, 60)
+        usable_width = table_width - 6  # Column separators
+        
+        # Proportional: Status 10%, ID 11%, Type 7%, Description 22%, Provider 8%, Model 11%, Cost 8%, Tokens 8%, Age 7%
+        status_w = max(8, int(usable_width * 0.10))
+        id_w = max(10, int(usable_width * 0.11))
+        type_w = max(6, int(usable_width * 0.07))
+        provider_w = max(8, int(usable_width * 0.08))
+        model_w = max(10, int(usable_width * 0.11))
+        cost_w = max(6, int(usable_width * 0.08))
+        tokens_w = max(6, int(usable_width * 0.08))
+        age_w = max(4, int(usable_width * 0.07))
+        desc_w = usable_width - status_w - id_w - type_w - provider_w - model_w - cost_w - tokens_w - age_w
+        desc_w = max(15, desc_w)
+        
+        table = self.query_one(DataTable)
+        table.add_column("Status", key="status", width=status_w)
+        table.add_column("ID", key="id", width=id_w)
+        table.add_column("Type", key="type", width=type_w)
+        table.add_column("Description", key="description", width=desc_w)
+        table.add_column("Provider", key="provider", width=provider_w)
+        table.add_column("Model", key="model", width=model_w)
+        table.add_column("Cost", key="cost", width=cost_w)
+        table.add_column("Tokens", key="tokens", width=tokens_w)
+        table.add_column("Age", key="age", width=age_w)
+    
+    async def update_tasks(self, tasks: list[Task]) -> None:
+        """Update the table with new task data."""
+        self.tasks = tasks
+        
+        table = self.query_one(DataTable)
+        
+        # Remember current selection
+        current_key = self._selected_row_key
+        
+        # Clear and repopulate
+        table.clear()
+        
+        for task in tasks:
+            status_display = self._format_status(task.status)
+            tokens_display = f"{task.token_usage.total_tokens:,}"
+            cost_display = self._format_cost(task.token_usage.cost)
+            age_display = self._format_age(task.created_at)
+            model_display = format_model(task.model)
+            description_display = task.description[:33] + "..." if len(task.description) > 35 else task.description
+            
+            table.add_row(
+                status_display,
+                task.id,
+                task.type,
+                description_display,
+                task.provider,
+                model_display,
+                cost_display,
+                tokens_display,
+                age_display,
+                key=task.id,
+            )
+        
+        # Restore selection if possible
+        if current_key:
+            try:
+                row_index = table.get_row_index(current_key)
+                table.cursor_coordinate = (row_index, 0)
+                self._selected_row_key = current_key
+            except Exception:
+                pass
+    
+    def _format_status(self, status: str) -> str:
+        """Format status with color markup."""
+        status_colors = {
+            "pending": "[dim]○ pending[/]",
+            "queued": "[yellow]◐ queued[/]",
+            "running": "[cyan]● running[/]",
+            "completed": "[green]✓ done[/]",
+            "failed": "[red]✗ failed[/]",
+            "cancelled": "[dim]⊘ cancel[/]",
+        }
+        return status_colors.get(status, f"[yellow]{status}[/]")
+    
+    def _format_cost(self, cost: float) -> str:
+        """Format cost in dollars."""
+        if cost == 0:
+            return "[dim]$0.00[/]"
+        elif cost < 0.01:
+            return f"${cost:.4f}"
+        else:
+            return f"${cost:.2f}"
+    
+    def _format_age(self, created_at: datetime) -> str:
+        """Format age in human-readable form."""
+        # Handle naive datetimes from MongoDB (assume UTC)
+        if created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=UTC)
+        age = datetime.now(UTC) - created_at
+        
+        if age.total_seconds() < 60:
+            return f"{int(age.total_seconds())}s"
+        elif age.total_seconds() < 3600:
+            return f"{int(age.total_seconds() / 60)}m"
+        elif age.total_seconds() < 86400:
+            return f"{int(age.total_seconds() / 3600)}h"
+        else:
+            return f"{int(age.total_seconds() / 86400)}d"
+    
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle row selection."""
+        self._selected_row_key = str(event.row_key.value) if event.row_key else None
+    
+    def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
+        """Handle row highlight (cursor movement)."""
+        self._selected_row_key = str(event.row_key.value) if event.row_key else None
+    
+    def get_selected_task_id(self) -> str | None:
+        """Get the currently selected task ID."""
+        table = self.query_one(DataTable)
+        if table.cursor_row is not None:
+            # Get the ID from the second column (index 1)
+            return str(table.get_cell_at((table.cursor_row, 1)))
+        return self._selected_row_key
+
+    @property
+    def row_count(self) -> int:
+        """Get the number of rows in the table."""
+        table = self.query_one(DataTable)
+        return table.row_count
+
+    @property
+    def column_count(self) -> int:
+        """Get the number of columns in the table."""
+        table = self.query_one(DataTable)
+        return len(table.columns)
+
+    @property
+    def cursor_row(self) -> int | None:
+        """Get the current cursor row."""
+        table = self.query_one(DataTable)
+        return table.cursor_row