@anastops/cli 1.0.0 → 1.2.0

package/ranger-tui/ranger_tui/screens/dashboard.py

@@ -0,0 +1,232 @@
+"""
+Dashboard screen - Main view with sessions list.
+"""
+
+from datetime import datetime, UTC
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.binding import Binding
+from textual.containers import Horizontal
+from textual.widgets import DataTable, Footer
+
+from ranger_tui.widgets import TopBar, Sidebar
+from ranger_tui.theme import format_status
+
+
+class DashboardScreen(Screen):
+    """Main dashboard screen showing all sessions."""
+    
+    BINDINGS = [
+        Binding("enter", "open_session", "Open", show=True),
+        Binding("n", "new_session", "New", show=True),
+        Binding("escape", "noop", show=False),  # Disable escape on dashboard
+    ]
+    
+    def compose(self) -> ComposeResult:
+        """Compose the dashboard layout."""
+        yield TopBar()
+        with Horizontal(id="main"):
+            yield DataTable(id="sessions-table", cursor_type="row")
+            yield Sidebar(title="Summary")
+        yield Footer()
+    
+    async def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        # Setup table after a brief delay to ensure layout is complete
+        self.call_later(self._setup_table)
+        
+        # Auto-refresh
+        self.set_interval(2.0, self._refresh)
+        
+        # Focus on sessions table after setup
+        self.call_later(self._focus_sessions_table)
+    
+    def _focus_sessions_table(self) -> None:
+        """Focus on the sessions table."""
+        try:
+            table = self.query_one("#sessions-table", DataTable)
+            table.focus()
+            if table.row_count > 0:
+                table.cursor_coordinate = (0, 0)
+        except Exception:
+            pass
+    
+    async def _setup_table(self) -> None:
+        """Setup table with proper column widths after layout is complete."""
+        table = self.query_one("#sessions-table", DataTable)
+        
+        # Skip if columns already added
+        if table.columns:
+            return
+            
+        table.zebra_stripes = True
+        
+        # Get actual table content width (excluding borders)
+        try:
+            # Use the table's content region width
+            table_width = table.content_region.width
+            if table_width < 40:
+                # Fallback: calculate from app size
+                table_width = self.app.size.width - 34  # Sidebar(28) + padding(6)
+        except Exception:
+            table_width = 100  # Fallback for wide terminal
+        
+        # Ensure minimum reasonable width
+        table_width = max(table_width, 50)
+        
+        # Subtract space for column separators (4 separators * ~1 char each)
+        usable_width = table_width - 4
+        
+        # Proportional distribution to fill the table width:
+        # Status: 15%, Tasks: 10%, Tokens: 12%, Age: 8%, Objective: 55%
+        status_w = int(usable_width * 0.15)
+        tasks_w = int(usable_width * 0.10)
+        tokens_w = int(usable_width * 0.12)
+        age_w = int(usable_width * 0.08)
+        objective_w = usable_width - status_w - tasks_w - tokens_w - age_w
+        
+        # Ensure reasonable minimums without exceeding total
+        status_w = max(8, status_w)
+        tasks_w = max(5, tasks_w)
+        tokens_w = max(6, tokens_w)
+        age_w = max(4, age_w)
+        objective_w = max(15, objective_w)
+        
+        table.add_column("Status", key="status", width=status_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("Age", key="age", width=age_w)
+        
+        # Initial load
+        await self._refresh()
+    
+    async def _refresh(self) -> None:
+        """Refresh the display."""
+        self._update_connection_status()
+        await self._update_sessions()
+        self._update_summary()
+    
+    def _update_connection_status(self) -> None:
+        """Update connection status in topbar."""
+        topbar = self.query_one(TopBar)
+        topbar.set_connection_status(
+            self.app.mongo_connected,
+            self.app.redis_connected
+        )
+    
+    async def _update_sessions(self) -> None:
+        """Update sessions table."""
+        sessions = self.app.sessions
+        table = self.query_one("#sessions-table", DataTable)
+        
+        # Remember selection
+        selected_row = table.cursor_row
+        
+        # Clear and repopulate
+        table.clear()
+        
+        for session in sessions:
+            status = format_status(session.status)
+            objective = session.objective
+            tasks = self._format_tasks(session.metadata)
+            tokens = f"{session.metadata.total_tokens:,}"
+            age = self._format_age(session.created_at)
+            
+            table.add_row(status, objective, tasks, tokens, age, key=session.id)
+        
+        # Restore selection
+        if selected_row is not None and selected_row < table.row_count:
+            table.cursor_coordinate = (selected_row, 0)
+    
+    def _update_summary(self) -> None:
+        """Update summary sidebar."""
+        sessions = self.app.sessions
+        
+        total = len(sessions)
+        active = sum(1 for s in sessions if s.status == "active")
+        total_tasks = sum(s.metadata.tasks_total for s in sessions)
+        completed_tasks = sum(s.metadata.tasks_completed for s in sessions)
+        running_tasks = sum(s.metadata.tasks_running for s in sessions)
+        total_tokens = sum(s.metadata.total_tokens for s in sessions)
+        total_cost = sum(s.metadata.total_cost for s in sessions)
+        
+        sidebar = self.query_one(Sidebar)
+        running_indicator = f" ([cyan]●[/] {running_tasks} running)" if running_tasks > 0 else ""
+        sidebar.update_content(
+            f"Sessions: {total} ({active} active)\n"
+            f"Tasks: {completed_tasks}/{total_tasks}{running_indicator}\n"
+            f"Tokens: {total_tokens:,}\n"
+            f"Cost: ${total_cost:.4f}"
+        )
+    
+    def _format_tasks(self, metadata) -> 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 = ["◐", "◓", "◑", "◒"]
+            # Use current time to animate
+            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
+        seconds = age.total_seconds()
+        
+        if seconds < 60:
+            return f"{int(seconds)}s"
+        elif seconds < 3600:
+            return f"{int(seconds / 60)}m"
+        elif seconds < 86400:
+            return f"{int(seconds / 3600)}h"
+        else:
+            return f"{int(seconds / 86400)}d"
+    
+    async def action_open_session(self) -> None:
+        """Open selected session."""
+        table = self.query_one("#sessions-table", DataTable)
+        if table.cursor_row is not None and table.row_count > 0:
+            row_key = table.coordinate_to_cell_key((table.cursor_row, 0)).row_key
+            session_id = str(row_key.value) if row_key else None
+            
+            if session_id:
+                from ranger_tui.screens.session import SessionScreen
+                await self.app.push_screen(SessionScreen(session_id))
+    
+    async def action_new_session(self) -> None:
+        """Create a new session."""
+        from ranger_tui.screens.modals import NewSessionModal
+        
+        async def on_submit(objective: str) -> None:
+            if objective:
+                session = await self.app.client.create_session(objective)
+                self.app.notify(f"Created: {session.id[:8]}")
+                await self.app._refresh_data()
+        
+        await self.app.push_screen(NewSessionModal(), on_submit)
+    
+    def action_noop(self) -> None:
+        """Do nothing - escape disabled on dashboard."""
+        pass
+    
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle double-click / enter on row."""
+        session_id = str(event.row_key.value) if event.row_key else None
+        if session_id:
+            from ranger_tui.screens.session import SessionScreen
+            self.app.push_screen(SessionScreen(session_id))

package/ranger-tui/ranger_tui/screens/help.py

@@ -0,0 +1,103 @@
+"""
+Help screen - Shows keyboard shortcuts and usage information.
+"""
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.binding import Binding
+from textual.containers import Container, VerticalScroll
+from textual.widgets import Static, Button, Markdown
+
+
+HELP_CONTENT = """
+# Ranger TUI Help
+
+## Global Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `q` | Quit application |
+| `?` | Show this help |
+| `r` | Refresh data |
+| `d` | Toggle dark/light mode |
+| `Ctrl+P` | Open command palette |
+| `Escape` | Go back / Close modal |
+
+## Dashboard (Sessions List)
+
+| Key | Action |
+|-----|--------|
+| `n` | Create new session |
+| `Enter` | Open selected session |
+| `a` | Archive selected session |
+| `p` | Purge selected session |
+| `f` | Fork selected session |
+| `j` / `↓` | Move down |
+| `k` / `↑` | Move up |
+
+## Session Detail
+
+| Key | Action |
+|-----|--------|
+| `t` | Create new task |
+| `Enter` | Open selected task |
+| `e` | Execute/queue task |
+| `c` | Cancel task |
+| `y` | Retry failed task |
+| `Tab` | Switch tabs |
+
+## Task Detail
+
+| Key | Action |
+|-----|--------|
+| `e` | Execute task |
+| `c` | Cancel task |
+| `y` | Retry task |
+| `Tab` | Switch tabs |
+
+## Navigation
+
+- Use `j`/`k` or arrow keys to move through lists
+- Press `Enter` to select/open items
+- Press `Escape` to go back
+- Use `Tab` to switch between tabs
+
+## Command Palette
+
+Press `Ctrl+P` to open the command palette for quick access to all commands:
+
+- Session operations (spawn, archive, purge, fork)
+- Task operations (create, execute, cancel, retry)
+- Agent operations (create, deploy, retire)
+- System operations (health check, metrics)
+
+---
+
+Press `Escape` or `Enter` to close this help.
+"""
+
+
+class HelpScreen(ModalScreen):
+    """Help modal screen."""
+    
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+        Binding("enter", "close", "Close", show=False),
+    ]
+    
+    def compose(self) -> ComposeResult:
+        """Compose the help modal."""
+        with Container(id="help-modal"):
+            yield Static("Help", id="help-title")
+            with VerticalScroll(id="help-content"):
+                yield Markdown(HELP_CONTENT)
+            yield Button("Close", id="help-close", variant="primary")
+    
+    def action_close(self) -> None:
+        """Close the help modal."""
+        self.dismiss()
+    
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press."""
+        if event.button.id == "help-close":
+            self.dismiss()

package/ranger-tui/ranger_tui/screens/modals.py

@@ -0,0 +1,95 @@
+"""
+Modal screens for user input.
+"""
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.binding import Binding
+from textual.containers import Container, Vertical, Horizontal
+from textual.widgets import Static, Button, Input, Label, Select
+
+
+class NewSessionModal(ModalScreen[str]):
+    """Modal for creating a new session."""
+    
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+    
+    def compose(self) -> ComposeResult:
+        """Compose the modal layout."""
+        with Container(id="modal"):
+            yield Static("New Session", id="modal-title")
+            yield Input(placeholder="What do you want to accomplish?", id="objective")
+            with Horizontal(id="modal-buttons"):
+                yield Button("Create", variant="primary", id="btn-create")
+                yield Button("Cancel", id="btn-cancel")
+    
+    def on_mount(self) -> None:
+        self.query_one("#objective", Input).focus()
+    
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-create":
+            objective = self.query_one("#objective", Input).value
+            if objective.strip():
+                self.dismiss(objective.strip())
+        else:
+            self.dismiss(None)
+    
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        objective = event.value
+        if objective.strip():
+            self.dismiss(objective.strip())
+    
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class NewTaskModal(ModalScreen[dict]):
+    """Modal for creating a new task."""
+    
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+    
+    def compose(self) -> ComposeResult:
+        """Compose the modal layout."""
+        with Container(id="modal"):
+            yield Static("New Task", id="modal-title")
+            yield Label("Description")
+            yield Input(placeholder="Brief description", id="description")
+            yield Label("Prompt")
+            yield Input(placeholder="Detailed instructions", id="prompt")
+            yield Label("Type")
+            yield Select([
+                ("Code", "code"),
+                ("Test", "test"),
+                ("Docs", "documentation"),
+                ("Analysis", "analysis"),
+                ("Other", "other"),
+            ], id="type-select", value="code")
+            with Horizontal(id="modal-buttons"):
+                yield Button("Create", variant="primary", id="btn-create")
+                yield Button("Cancel", id="btn-cancel")
+    
+    def on_mount(self) -> None:
+        self.query_one("#description", Input).focus()
+    
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-create":
+            desc = self.query_one("#description", Input).value
+            prompt = self.query_one("#prompt", Input).value
+            task_type = self.query_one("#type-select", Select).value
+            
+            if desc.strip() and prompt.strip():
+                self.dismiss({
+                    "description": desc.strip(),
+                    "prompt": prompt.strip(),
+                    "type": task_type,
+                    "provider": "claude",
+                })
+        else:
+            self.dismiss(None)
+    
+    def action_cancel(self) -> None:
+        self.dismiss(None)