@anastops/cli 1.0.0 → 1.2.0

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

@@ -0,0 +1,289 @@
+"""
+Session detail screen - View tasks and agents in a session.
+"""
+
+from datetime import datetime
+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, TabbedContent, TabPane, RichLog
+
+from ranger_tui.data import SessionReport
+from ranger_tui.widgets import TopBar, Sidebar
+from ranger_tui.theme import format_status, format_model, STATUS_SYMBOLS
+
+
+class SessionScreen(Screen):
+    """Session detail screen with tasks and agents."""
+    
+    BINDINGS = [
+        Binding("enter", "open_task", "Open", show=True),
+        Binding("t", "new_task", "New Task", show=True),
+    ]
+    
+    session_id: str = ""
+    report: SessionReport | None = None
+    
+    def __init__(self, session_id: str):
+        super().__init__()
+        self.session_id = session_id
+    
+    def compose(self) -> ComposeResult:
+        """Compose the session detail layout."""
+        yield TopBar(title="Loading...")
+        with Horizontal(id="main"):
+            with TabbedContent(id="tabs"):
+                with TabPane("Tasks", id="tasks-tab"):
+                    yield DataTable(id="tasks-table", cursor_type="row")
+                with TabPane("Agents", id="agents-tab"):
+                    yield DataTable(id="agents-table", cursor_type="row")
+                with TabPane("Logs", id="logs-tab"):
+                    yield RichLog(id="activity-log", highlight=True, markup=True)
+            yield Sidebar(title="Details")
+        yield Footer()
+    
+    async def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        # Setup tables after layout is complete
+        self.call_later(self._setup_tables)
+        
+        # Auto-refresh
+        self.set_interval(2.0, self._load_session)
+        
+        # Focus on tasks table after a brief delay (after data loads)
+        self.call_later(self._focus_tasks_table)
+    
+    def _focus_tasks_table(self) -> None:
+        """Focus on the tasks table."""
+        try:
+            tasks_table = self.query_one("#tasks-table", DataTable)
+            tasks_table.focus()
+            # Set cursor to first row if there are rows
+            if tasks_table.row_count > 0:
+                tasks_table.cursor_coordinate = (0, 0)
+        except Exception:
+            pass
+    
+    async def _setup_tables(self) -> None:
+        """Setup tables with proportional column widths after layout is complete."""
+        # Calculate available width: terminal width - sidebar(28) - padding/borders(~6)
+        try:
+            terminal_width = self.app.size.width
+            table_width = terminal_width - 28 - 6
+        except Exception:
+            table_width = 100
+        
+        table_width = max(table_width, 60)
+        usable_width = table_width - 5  # Space for column separators
+        
+        # Setup tasks table with proportional widths
+        # Status: 10%, Type: 8%, Description: 28%, Provider: 12%, Model: 16%, Cost: 10%, Tokens: 14%
+        tasks_table = self.query_one("#tasks-table", DataTable)
+        if not tasks_table.columns:
+            tasks_table.zebra_stripes = True
+            status_w = max(8, int(usable_width * 0.10))
+            type_w = max(6, int(usable_width * 0.08))
+            provider_w = max(8, int(usable_width * 0.12))
+            model_w = max(10, int(usable_width * 0.16))
+            cost_w = max(6, int(usable_width * 0.10))
+            tokens_w = max(8, int(usable_width * 0.14))
+            desc_w = usable_width - status_w - type_w - provider_w - model_w - cost_w - tokens_w
+            desc_w = max(15, desc_w)
+            
+            tasks_table.add_column("Status", key="status", width=status_w)
+            tasks_table.add_column("Type", key="type", width=type_w)
+            tasks_table.add_column("Description", key="description", width=desc_w)
+            tasks_table.add_column("Provider", key="provider", width=provider_w)
+            tasks_table.add_column("Model", key="model", width=model_w)
+            tasks_table.add_column("Cost", key="cost", width=cost_w)
+            tasks_table.add_column("Tokens", key="tokens", width=tokens_w)
+        
+        # Setup agents table with proportional widths
+        # Status: 12%, Name: 30%, Role: 28%, Provider: 15%, Tasks: 15%
+        agents_table = self.query_one("#agents-table", DataTable)
+        if not agents_table.columns:
+            agents_table.zebra_stripes = True
+            status_w = max(8, int(usable_width * 0.12))
+            name_w = max(12, int(usable_width * 0.30))
+            role_w = max(10, int(usable_width * 0.28))
+            provider_w = max(8, int(usable_width * 0.15))
+            tasks_w = max(6, int(usable_width * 0.15))
+            
+            agents_table.add_column("Status", key="status", width=status_w)
+            agents_table.add_column("Name", key="name", width=name_w)
+            agents_table.add_column("Role", key="role", width=role_w)
+            agents_table.add_column("Provider", key="provider", width=provider_w)
+            agents_table.add_column("Tasks", key="tasks", width=tasks_w)
+        
+        # Load data
+        await self._load_session()
+    
+    async def _load_session(self) -> None:
+        """Load session data."""
+        self.report = await self.app.client.get_session_report(self.session_id)
+        
+        if self.report:
+            self._update_header()
+            self._update_tasks()
+            self._update_agents()
+            self._update_details()
+            self._update_logs()
+    
+    def _update_header(self) -> None:
+        """Update session header in topbar."""
+        if not self.report:
+            return
+        
+        session = self.report.session
+        topbar = self.query_one(TopBar)
+        
+        symbol = STATUS_SYMBOLS.get(session.status, "?")
+        topbar.title = f"{symbol} {session.objective}"
+        topbar.set_connection_status(self.app.mongo_connected, self.app.redis_connected)
+    
+    def _update_tasks(self) -> None:
+        """Update tasks table."""
+        if not self.report:
+            return
+        
+        table = self.query_one("#tasks-table", DataTable)
+        selected_row = table.cursor_row
+        
+        table.clear()
+        
+        for task in self.report.tasks:
+            status = format_status(task.status)
+            tokens = f"{task.token_usage.total_tokens:,}"
+            cost = self._format_cost(task.token_usage.cost)
+            model_display = format_model(task.model)
+            
+            table.add_row(status, task.type, task.description, task.provider, model_display, cost, tokens, key=task.id)
+        
+        if selected_row is not None and selected_row < table.row_count:
+            table.cursor_coordinate = (selected_row, 0)
+    
+    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 _update_agents(self) -> None:
+        """Update agents table."""
+        if not self.report:
+            return
+        
+        table = self.query_one("#agents-table", DataTable)
+        selected_row = table.cursor_row
+        
+        table.clear()
+        
+        for agent in self.report.agents:
+            status = format_status(agent.status)
+            tasks = f"{agent.tasks_completed}/{agent.tasks_completed + agent.tasks_failed}"
+            
+            table.add_row(status, agent.name, agent.role, agent.provider, tasks, key=agent.id)
+        
+        if selected_row is not None and selected_row < table.row_count:
+            table.cursor_coordinate = (selected_row, 0)
+    
+    def _update_details(self) -> None:
+        """Update details sidebar."""
+        if not self.report:
+            return
+        
+        session = self.report.session
+        stats = self.report.statistics
+        
+        sidebar = self.query_one(Sidebar)
+        sidebar.update_content(
+            f"ID: {session.id[:12]}...\n"
+            f"Status: {session.status}\n"
+            f"Created: {session.created_at.strftime('%m-%d %H:%M')}\n"
+            f"\n"
+            f"[bold]Tasks[/]\n"
+            f"  [green]✓[/] {stats.tasks.completed} completed\n"
+            f"  [red]✗[/] {stats.tasks.failed} failed\n"
+            f"  [yellow]●[/] {stats.tasks.running} running\n"
+            f"  [dim]○[/] {stats.tasks.pending} pending\n"
+            f"\n"
+            f"Tokens: {stats.total_tokens:,}\n"
+            f"Cost: ${stats.total_cost_usd:.4f}"
+        )
+    
+    def _update_logs(self) -> None:
+        """Update activity log."""
+        if not self.report:
+            return
+        
+        log = self.query_one("#activity-log", RichLog)
+        log.clear()
+        
+        for task in sorted(self.report.tasks, key=lambda t: t.created_at):
+            time_str = task.created_at.strftime("%H:%M:%S")
+            
+            # Status with color
+            status_colors = {
+                "completed": "green",
+                "failed": "red",
+                "running": "yellow",
+                "pending": "dim",
+            }
+            color = status_colors.get(task.status, "white")
+            symbol = STATUS_SYMBOLS.get(task.status, "?")
+            
+            log.write(f"[dim]{time_str}[/] [{color}]{symbol}[/] [bold]{task.type}[/]: {task.description[:50]}")
+            
+            if task.error:
+                log.write(f"  [red]ERROR: {task.error[:60]}[/]")
+            
+            if task.output and task.output.content:
+                preview = task.output.content[:80].replace('\n', ' ')
+                log.write(f"  [dim]→ {preview}...[/]")
+        
+        if not self.report.tasks:
+            log.write("[dim]No activity yet[/]")
+    
+    async def action_open_task(self) -> None:
+        """Open selected task."""
+        tabs = self.query_one("#tabs", TabbedContent)
+        
+        if tabs.active == "tasks-tab":
+            table = self.query_one("#tasks-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
+                task_id = str(row_key.value) if row_key else None
+                
+                if task_id:
+                    from ranger_tui.screens.task import TaskScreen
+                    await self.app.push_screen(TaskScreen(task_id))
+    
+    async def action_new_task(self) -> None:
+        """Create a new task."""
+        from ranger_tui.screens.modals import NewTaskModal
+        
+        async def on_submit(data: dict) -> None:
+            if data:
+                task = await self.app.client.create_task(
+                    session_id=self.session_id,
+                    task_type=data.get("type", "other"),
+                    description=data.get("description", ""),
+                    prompt=data.get("prompt", ""),
+                    provider=data.get("provider", "claude"),
+                )
+                self.app.notify(f"Created task: {task.id[:8]}")
+                await self._load_session()
+        
+        await self.app.push_screen(NewTaskModal(), on_submit)
+    
+    def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
+        """Handle enter on row."""
+        if event.data_table.id == "tasks-table":
+            task_id = str(event.row_key.value) if event.row_key else None
+            if task_id:
+                from ranger_tui.screens.task import TaskScreen
+                self.app.push_screen(TaskScreen(task_id))

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

@@ -0,0 +1,187 @@
+"""
+Task detail screen - View task details, input, output, and errors.
+"""
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.containers import Horizontal
+from textual.widgets import Footer, TabbedContent, TabPane, RichLog, Markdown
+
+from ranger_tui.data import Task
+from ranger_tui.widgets import TopBar, Sidebar
+from ranger_tui.theme import STATUS_SYMBOLS
+
+
+class TaskScreen(Screen):
+    """Task detail screen."""
+    
+    task_id: str = ""
+    task: Task | None = None
+    
+    def __init__(self, task_id: str):
+        super().__init__()
+        self.task_id = task_id
+    
+    def compose(self) -> ComposeResult:
+        """Compose the task detail layout."""
+        yield TopBar(title="Loading...")
+        with Horizontal(id="main"):
+            with TabbedContent(id="tabs"):
+                with TabPane("Output", id="output-tab"):
+                    yield RichLog(id="output-log", highlight=True, markup=True)
+                with TabPane("Input", id="input-tab"):
+                    yield RichLog(id="input-log", highlight=True, markup=True)
+                with TabPane("Error", id="error-tab"):
+                    yield RichLog(id="error-log", highlight=True, markup=True)
+            yield Sidebar(title="Info")
+        yield Footer()
+    
+    async def on_mount(self) -> None:
+        """Called when screen is mounted."""
+        await self._load_task()
+        self.set_interval(2.0, self._load_task)
+        
+        # Focus on output log
+        self.call_later(self._focus_output)
+    
+    def _focus_output(self) -> None:
+        """Focus on the output log."""
+        try:
+            output_log = self.query_one("#output-log", RichLog)
+            output_log.focus()
+        except Exception:
+            pass
+    
+    async def _load_task(self) -> None:
+        """Load task data."""
+        self.task = await self.app.client.get_task(self.task_id)
+        
+        if self.task:
+            self._update_header()
+            self._update_output()
+            self._update_input()
+            self._update_error()
+            self._update_info()
+    
+    def _update_header(self) -> None:
+        """Update task header in topbar."""
+        if not self.task:
+            return
+        
+        topbar = self.query_one(TopBar)
+        symbol = STATUS_SYMBOLS.get(self.task.status, "?")
+        topbar.title = f"{symbol} {self.task.description}"
+        topbar.set_connection_status(self.app.mongo_connected, self.app.redis_connected)
+    
+    def _update_output(self) -> None:
+        """Update output tab."""
+        if not self.task:
+            return
+        
+        log = self.query_one("#output-log", RichLog)
+        log.clear()
+        
+        if self.task.output and self.task.output.content:
+            # Task completed - show final output
+            log.write(self.task.output.content)
+            
+            if self.task.output.files_modified:
+                log.write("\n[bold]Files Modified[/]")
+                for f in self.task.output.files_modified:
+                    log.write(f"  [green]•[/] {f}")
+            
+            if self.task.output.artifacts:
+                log.write("\n[bold]Artifacts[/]")
+                for a in self.task.output.artifacts:
+                    log.write(f"  [blue]•[/] {a}")
+        elif self.task.logs:
+            # Task running - show streaming logs
+            if self.task.status == "running":
+                log.write("[cyan]● LIVE[/] [dim]Streaming output...[/]\n")
+            log.write(self.task.logs)
+        else:
+            # No output yet
+            status_msgs = {
+                "pending": "[dim]Task is pending...[/]",
+                "queued": "[yellow]Task is queued...[/]",
+                "running": "[yellow]Task is running... (waiting for output)[/]",
+                "cancelled": "[red]Task was cancelled.[/]",
+            }
+            log.write(status_msgs.get(self.task.status, "[dim]No output.[/]"))
+    
+    def _update_input(self) -> None:
+        """Update input tab."""
+        if not self.task:
+            return
+        
+        log = self.query_one("#input-log", RichLog)
+        log.clear()
+        
+        log.write("[bold]Prompt[/]")
+        log.write(self.task.input.prompt)
+        
+        if self.task.input.context_files:
+            log.write("\n[bold]Context Files[/]")
+            for f in self.task.input.context_files:
+                log.write(f"  [dim]•[/] {f}")
+        
+        if self.task.input.agent:
+            log.write(f"\n[bold]Agent[/]\n{self.task.input.agent}")
+        
+        if self.task.input.skills:
+            log.write("\n[bold]Skills[/]")
+            for s in self.task.input.skills:
+                log.write(f"  [blue]•[/] {s}")
+    
+    def _update_error(self) -> None:
+        """Update error tab."""
+        if not self.task:
+            return
+        
+        log = self.query_one("#error-log", RichLog)
+        log.clear()
+        
+        if self.task.error:
+            log.write("[bold red]Error[/]")
+            log.write(f"[red]{self.task.error}[/]")
+        else:
+            log.write("[green]No errors.[/]")
+    
+    def _update_info(self) -> None:
+        """Update info sidebar."""
+        if not self.task:
+            return
+        
+        sidebar = self.query_one(Sidebar)
+        
+        duration = ""
+        if self.task.started_at and self.task.completed_at:
+            delta = self.task.completed_at - self.task.started_at
+            duration = f"{delta.total_seconds():.1f}s"
+        elif self.task.started_at:
+            duration = "[yellow]running...[/]"
+        
+        # Status color
+        status_colors = {
+            "completed": "green",
+            "failed": "red",
+            "running": "yellow",
+            "pending": "dim",
+        }
+        color = status_colors.get(self.task.status, "white")
+        
+        sidebar.update_content(
+            f"ID: {self.task.id[:12]}...\n"
+            f"Type: {self.task.type}\n"
+            f"Status: [{color}]{self.task.status}[/]\n"
+            f"Provider: {self.task.provider}\n"
+            f"Model: {self.task.model}\n"
+            f"\n"
+            f"Created: {self.task.created_at.strftime('%H:%M:%S')}\n"
+            f"Duration: {duration or 'N/A'}\n"
+            f"\n"
+            f"Tokens: {self.task.token_usage.total_tokens:,}\n"
+            f"Cost: ${self.task.token_usage.cost:.6f}\n"
+            f"\n"
+            f"Retries: {self.task.retry_count}/{self.task.max_retries}"
+        )