@anastops/cli 1.0.0 → 1.2.0

package/ranger-tui/ranger_tui/data/models.py

@@ -0,0 +1,151 @@
+"""
+Pydantic models for Anastops data types.
+"""
+
+from datetime import datetime
+from typing import Optional, Any
+from pydantic import BaseModel, Field
+
+
+class TokenUsage(BaseModel):
+    """Token usage metrics."""
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+    cost: float = 0.0
+
+
+class SessionMetadata(BaseModel):
+    """Session metadata."""
+    total_tokens: int = 0
+    total_cost: float = 0.0
+    agents_used: list[str] = Field(default_factory=list)
+    files_affected: list[str] = Field(default_factory=list)
+    tasks_total: int = 0
+    tasks_completed: int = 0
+    tasks_failed: int = 0
+    tasks_running: int = 0
+    tasks_pending: int = 0
+    tasks_queued: int = 0
+
+
+class Session(BaseModel):
+    """Orchestration session."""
+    id: str
+    user_id: str = "local"
+    parent_session_id: Optional[str] = None
+    fork_point: Optional[int] = None
+    fork_reason: Optional[str] = None
+    status: str = "active"
+    objective: str
+    created_at: datetime
+    updated_at: datetime
+    metadata: SessionMetadata = Field(default_factory=SessionMetadata)
+
+
+class TaskInput(BaseModel):
+    """Task input data."""
+    prompt: str = ""
+    context_files: list[str] = Field(default_factory=list)
+    agent: Optional[str] = None
+    skills: list[str] = Field(default_factory=list)
+
+
+class TaskOutput(BaseModel):
+    """Task output data."""
+    content: str = ""
+    artifacts: list[str] = Field(default_factory=list)
+    files_modified: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Task(BaseModel):
+    """Orchestration task."""
+    id: str
+    session_id: str
+    agent_id: Optional[str] = None
+    type: str = "other"
+    status: str = "pending"
+    description: str
+    input: TaskInput = Field(default_factory=TaskInput)
+    output: Optional[TaskOutput] = None
+    error: Optional[str] = None
+    complexity_score: int = 0
+    routing_tier: int = 3
+    provider: str = "claude"
+    model: str = "claude-sonnet"
+    token_usage: TokenUsage = Field(default_factory=TokenUsage)
+    created_at: datetime
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    dependencies: list[str] = Field(default_factory=list)
+    priority: int = 5
+    retry_count: int = 0
+    max_retries: int = 3
+    logs: Optional[str] = None  # Streaming logs captured during execution
+
+
+class Agent(BaseModel):
+    """AI agent."""
+    id: str
+    session_id: str
+    role: str = "implementer"
+    name: str
+    status: str = "idle"
+    provider: str = "claude"
+    model: str = "claude-sonnet"
+    current_task_id: Optional[str] = None
+    tasks_completed: int = 0
+    tasks_failed: int = 0
+    tokens_used: int = 0
+    created_at: datetime
+    last_activity_at: datetime
+    config: dict[str, Any] = Field(default_factory=dict)
+
+
+class Artifact(BaseModel):
+    """Generated artifact."""
+    id: str
+    session_id: str
+    task_id: Optional[str] = None
+    type: str = "other"
+    name: str
+    extension: str = ""
+    content: str = ""
+    content_hash: str = ""
+    size_bytes: int = 0
+    summary: str = ""
+    token_count: int = 0
+    relevance_score: int = 50
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime
+    updated_at: datetime
+
+
+class TaskStats(BaseModel):
+    """Task statistics."""
+    total: int = 0
+    pending: int = 0
+    queued: int = 0
+    running: int = 0
+    completed: int = 0
+    failed: int = 0
+    cancelled: int = 0
+
+
+class SessionStatistics(BaseModel):
+    """Session statistics."""
+    tasks: TaskStats = Field(default_factory=TaskStats)
+    total_tokens: int = 0
+    total_cost_usd: float = 0.0
+    agents_count: int = 0
+    artifacts_count: int = 0
+
+
+class SessionReport(BaseModel):
+    """Comprehensive session report."""
+    session: Session
+    statistics: SessionStatistics
+    tasks: list[Task] = Field(default_factory=list)
+    agents: list[Agent] = Field(default_factory=list)
+    artifacts: list[Artifact] = Field(default_factory=list)

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

@@ -0,0 +1,16 @@
+"""
+Screens for Ranger TUI.
+"""
+
+from .dashboard import DashboardScreen
+from .session import SessionScreen
+from .task import TaskScreen
+from .modals import NewSessionModal, NewTaskModal
+
+__all__ = [
+    "DashboardScreen",
+    "SessionScreen",
+    "TaskScreen",
+    "NewSessionModal",
+    "NewTaskModal",
+]

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

@@ -0,0 +1,357 @@
+"""
+Command palette screen - Quick access to all operations.
+"""
+
+from typing import Callable, Awaitable
+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, Input, OptionList
+from textual.widgets.option_list import Option
+
+
+class Command:
+    """A command that can be executed from the palette."""
+    
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        category: str,
+        action: Callable[[], Awaitable[None]],
+    ):
+        self.name = name
+        self.description = description
+        self.category = category
+        self.action = action
+
+
+class CommandPaletteScreen(ModalScreen):
+    """Command palette for quick access to all operations."""
+    
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=True),
+        Binding("enter", "execute", "Execute", show=False),
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+    ]
+    
+    def __init__(self):
+        super().__init__()
+        self.commands: list[Command] = []
+        self.filtered_commands: list[Command] = []
+    
+    def compose(self) -> ComposeResult:
+        """Compose the command palette."""
+        with Container(id="palette-container"):
+            yield Static("Command Palette", id="palette-title")
+            yield Input(placeholder="Type to search commands...", id="palette-search")
+            yield OptionList(id="palette-list")
+    
+    def on_mount(self) -> None:
+        """Initialize commands on mount."""
+        self._build_commands()
+        self._update_list("")
+        self.query_one("#palette-search", Input).focus()
+    
+    def _build_commands(self) -> None:
+        """Build the list of available commands."""
+        self.commands = [
+            # Session commands
+            Command(
+                "New Session",
+                "Create a new orchestration session",
+                "Session",
+                self._new_session,
+            ),
+            Command(
+                "Archive Session",
+                "Archive the current/selected session",
+                "Session",
+                self._archive_session,
+            ),
+            Command(
+                "Purge Session",
+                "Permanently delete a session",
+                "Session",
+                self._purge_session,
+            ),
+            Command(
+                "Purge All Archived",
+                "Delete all archived sessions",
+                "Session",
+                self._purge_all_archived,
+            ),
+            Command(
+                "Fork Session",
+                "Create a fork of the current session",
+                "Session",
+                self._fork_session,
+            ),
+            Command(
+                "Session Report",
+                "View comprehensive session report",
+                "Session",
+                self._session_report,
+            ),
+            Command(
+                "Session Cost",
+                "View session cost breakdown",
+                "Session",
+                self._session_cost,
+            ),
+            
+            # Task commands
+            Command(
+                "New Task",
+                "Create a new task in current session",
+                "Task",
+                self._new_task,
+            ),
+            Command(
+                "Execute Task",
+                "Queue selected task for execution",
+                "Task",
+                self._execute_task,
+            ),
+            Command(
+                "Cancel Task",
+                "Cancel the selected task",
+                "Task",
+                self._cancel_task,
+            ),
+            Command(
+                "Retry Task",
+                "Retry a failed task",
+                "Task",
+                self._retry_task,
+            ),
+            
+            # Agent commands
+            Command(
+                "New Agent",
+                "Create a new agent",
+                "Agent",
+                self._new_agent,
+            ),
+            Command(
+                "Deploy Agent",
+                "Deploy an agent to a task",
+                "Agent",
+                self._deploy_agent,
+            ),
+            Command(
+                "Retire Agent",
+                "Retire an agent",
+                "Agent",
+                self._retire_agent,
+            ),
+            
+            # System commands
+            Command(
+                "Refresh",
+                "Refresh all data",
+                "System",
+                self._refresh,
+            ),
+            Command(
+                "Health Check",
+                "Check system health",
+                "System",
+                self._health_check,
+            ),
+            Command(
+                "Toggle Dark Mode",
+                "Switch between dark and light theme",
+                "System",
+                self._toggle_dark,
+            ),
+            Command(
+                "Show Help",
+                "Display help information",
+                "System",
+                self._show_help,
+            ),
+            Command(
+                "Quit",
+                "Exit the application",
+                "System",
+                self._quit,
+            ),
+        ]
+        
+        self.filtered_commands = self.commands.copy()
+    
+    def _update_list(self, filter_text: str) -> None:
+        """Update the command list based on filter."""
+        filter_lower = filter_text.lower()
+        
+        if filter_text:
+            self.filtered_commands = [
+                cmd for cmd in self.commands
+                if filter_lower in cmd.name.lower()
+                or filter_lower in cmd.description.lower()
+                or filter_lower in cmd.category.lower()
+            ]
+        else:
+            self.filtered_commands = self.commands.copy()
+        
+        option_list = self.query_one("#palette-list", OptionList)
+        option_list.clear_options()
+        
+        current_category = ""
+        for cmd in self.filtered_commands:
+            if cmd.category != current_category:
+                current_category = cmd.category
+                option_list.add_option(Option(f"── {current_category} ──", disabled=True))
+            
+            option_list.add_option(Option(f"{cmd.name} - {cmd.description}", id=cmd.name))
+    
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Handle search input changes."""
+        if event.input.id == "palette-search":
+            self._update_list(event.value)
+    
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle option selection."""
+        selected_name = event.option.id
+        for cmd in self.filtered_commands:
+            if cmd.name == selected_name:
+                self.dismiss()
+                self.app.call_later(cmd.action)
+                break
+    
+    def action_close(self) -> None:
+        """Close the palette."""
+        self.dismiss()
+    
+    async def action_execute(self) -> None:
+        """Execute highlighted command."""
+        option_list = self.query_one("#palette-list", OptionList)
+        if option_list.highlighted is not None:
+            highlighted_option = option_list.get_option_at_index(option_list.highlighted)
+            if highlighted_option and not highlighted_option.disabled:
+                selected_name = highlighted_option.id
+                for cmd in self.filtered_commands:
+                    if cmd.name == selected_name:
+                        self.dismiss()
+                        await cmd.action()
+                        break
+    
+    def action_move_up(self) -> None:
+        """Move selection up."""
+        option_list = self.query_one("#palette-list", OptionList)
+        option_list.action_cursor_up()
+    
+    def action_move_down(self) -> None:
+        """Move selection down."""
+        option_list = self.query_one("#palette-list", OptionList)
+        option_list.action_cursor_down()
+    
+    # Command implementations
+    
+    async def _new_session(self) -> None:
+        """Create 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: {session.id}")
+                await self.app._refresh_data()
+        
+        await self.app.push_screen(NewSessionModal(), on_submit)
+    
+    async def _archive_session(self) -> None:
+        """Archive session - requires dashboard context."""
+        self.app.notify("Use 'a' key on dashboard to archive selected session", severity="information")
+    
+    async def _purge_session(self) -> None:
+        """Purge session - requires dashboard context."""
+        self.app.notify("Use 'p' key on dashboard to purge selected session", severity="information")
+    
+    async def _purge_all_archived(self) -> None:
+        """Purge all archived sessions."""
+        from ranger_tui.screens.modals import ConfirmModal
+        
+        async def on_confirm(confirmed: bool) -> None:
+            if confirmed:
+                result = await self.app.client.purge_sessions_by_status("archived")
+                count = result.get("deleted_count", 0)
+                self.app.notify(f"Purged {count} archived sessions", severity="warning")
+                await self.app._refresh_data()
+        
+        await self.app.push_screen(
+            ConfirmModal(
+                title="Purge All Archived",
+                message="Permanently delete ALL archived sessions?",
+            ),
+            on_confirm,
+        )
+    
+    async def _fork_session(self) -> None:
+        """Fork session - requires dashboard context."""
+        self.app.notify("Use 'f' key on dashboard to fork selected session", severity="information")
+    
+    async def _session_report(self) -> None:
+        """View session report - requires session context."""
+        self.app.notify("Open a session to view its report", severity="information")
+    
+    async def _session_cost(self) -> None:
+        """View session cost - requires session context."""
+        self.app.notify("Open a session to view its cost", severity="information")
+    
+    async def _new_task(self) -> None:
+        """Create new task - requires session context."""
+        self.app.notify("Open a session and use 't' key to create a task", severity="information")
+    
+    async def _execute_task(self) -> None:
+        """Execute task - requires task context."""
+        self.app.notify("Select a task and use 'e' key to execute", severity="information")
+    
+    async def _cancel_task(self) -> None:
+        """Cancel task - requires task context."""
+        self.app.notify("Select a task and use 'c' key to cancel", severity="information")
+    
+    async def _retry_task(self) -> None:
+        """Retry task - requires task context."""
+        self.app.notify("Select a failed task and use 'y' key to retry", severity="information")
+    
+    async def _new_agent(self) -> None:
+        """Create new agent."""
+        from ranger_tui.screens.modals import NewAgentModal
+        self.app.notify("Agent creation requires session context", severity="information")
+    
+    async def _deploy_agent(self) -> None:
+        """Deploy agent."""
+        self.app.notify("Agent deployment requires agent and task context", severity="information")
+    
+    async def _retire_agent(self) -> None:
+        """Retire agent."""
+        self.app.notify("Agent retirement requires agent context", severity="information")
+    
+    async def _refresh(self) -> None:
+        """Refresh data."""
+        await self.app._refresh_data()
+        self.app.notify("Data refreshed")
+    
+    async def _health_check(self) -> None:
+        """Check system health."""
+        health = await self.app.client.health_check()
+        mongo_status = "OK" if health.get("mongodb") else "FAIL"
+        redis_status = "OK" if health.get("redis") else "FAIL"
+        self.app.notify(f"MongoDB: {mongo_status}, Redis: {redis_status}")
+    
+    async def _toggle_dark(self) -> None:
+        """Toggle dark mode."""
+        self.app.dark = not self.app.dark
+    
+    async def _show_help(self) -> None:
+        """Show help."""
+        from ranger_tui.screens.help import HelpScreen
+        await self.app.push_screen(HelpScreen())
+    
+    async def _quit(self) -> None:
+        """Quit application."""
+        self.app.exit()