@anastops/cli 1.1.0 → 1.2.0

package/ranger-tui/ranger_tui/actions/agent_actions.py

@@ -0,0 +1,74 @@
+"""
+Agent action handlers.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ranger_tui.app import RangerApp
+    from ranger_tui.data import DataClient
+
+
+class AgentActions:
+    """Agent-related actions."""
+    
+    def __init__(self, app: "RangerApp"):
+        self.app = app
+        self.client: "DataClient" = app.client
+    
+    async def create(
+        self,
+        session_id: str,
+        role: str,
+        name: str | None = None,
+        provider: str = "claude",
+        model: str = "claude-sonnet",
+    ) -> str | None:
+        """Create a new agent."""
+        try:
+            agent = await self.client.create_agent(
+                session_id=session_id,
+                role=role,
+                name=name,
+                provider=provider,
+                model=model,
+            )
+            self.app.notify(f"Created agent: {agent.id}", severity="information")
+            return agent.id
+        except Exception as e:
+            self.app.notify(f"Failed to create agent: {e}", severity="error")
+            return None
+    
+    async def deploy(self, agent_id: str, task_id: str) -> bool:
+        """Deploy an agent to a task."""
+        try:
+            success = await self.client.deploy_agent(agent_id, task_id)
+            if success:
+                self.app.notify(f"Deployed agent {agent_id} to task {task_id}", severity="information")
+            else:
+                self.app.notify("Failed to deploy agent", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error deploying agent: {e}", severity="error")
+            return False
+    
+    async def retire(self, agent_id: str) -> bool:
+        """Retire an agent."""
+        try:
+            success = await self.client.retire_agent(agent_id)
+            if success:
+                self.app.notify(f"Retired agent: {agent_id}", severity="information")
+            else:
+                self.app.notify("Failed to retire agent", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error retiring agent: {e}", severity="error")
+            return False
+    
+    async def get_status(self, agent_id: str):
+        """Get agent status."""
+        try:
+            return await self.client.get_agent(agent_id)
+        except Exception as e:
+            self.app.notify(f"Error getting agent: {e}", severity="error")
+            return None

package/ranger-tui/ranger_tui/actions/session_actions.py

@@ -0,0 +1,110 @@
+"""
+Session action handlers.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ranger_tui.app import RangerApp
+    from ranger_tui.data import DataClient
+
+
+class SessionActions:
+    """Session-related actions."""
+    
+    def __init__(self, app: "RangerApp"):
+        self.app = app
+        self.client: "DataClient" = app.client
+    
+    async def spawn(self, objective: str) -> str | None:
+        """Create a new session."""
+        try:
+            session = await self.client.create_session(objective)
+            self.app.notify(f"Created session: {session.id}", severity="information")
+            await self.app._refresh_data()
+            return session.id
+        except Exception as e:
+            self.app.notify(f"Failed to create session: {e}", severity="error")
+            return None
+    
+    async def archive(self, session_id: str) -> bool:
+        """Archive a session."""
+        try:
+            success = await self.client.archive_session(session_id)
+            if success:
+                self.app.notify(f"Archived session: {session_id}", severity="information")
+                await self.app._refresh_data()
+            else:
+                self.app.notify("Failed to archive session", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error archiving session: {e}", severity="error")
+            return False
+    
+    async def purge(self, session_id: str) -> bool:
+        """Permanently delete a session."""
+        try:
+            success = await self.client.purge_session(session_id)
+            if success:
+                self.app.notify(f"Purged session: {session_id}", severity="warning")
+                await self.app._refresh_data()
+            else:
+                self.app.notify("Failed to purge session", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error purging session: {e}", severity="error")
+            return False
+    
+    async def purge_by_status(self, status: str) -> int:
+        """Purge all sessions with a given status."""
+        try:
+            result = await self.client.purge_sessions_by_status(status)
+            count = result.get("deleted_count", 0)
+            if count > 0:
+                self.app.notify(f"Purged {count} {status} sessions", severity="warning")
+                await self.app._refresh_data()
+            else:
+                self.app.notify(f"No {status} sessions to purge", severity="information")
+            return count
+        except Exception as e:
+            self.app.notify(f"Error purging sessions: {e}", severity="error")
+            return 0
+    
+    async def fork(self, session_id: str, reason: str | None = None) -> str | None:
+        """Fork a session."""
+        try:
+            forked = await self.client.fork_session(session_id, reason)
+            if forked:
+                self.app.notify(f"Forked to: {forked.id}", severity="information")
+                await self.app._refresh_data()
+                return forked.id
+            else:
+                self.app.notify("Failed to fork session", severity="error")
+                return None
+        except Exception as e:
+            self.app.notify(f"Error forking session: {e}", severity="error")
+            return None
+    
+    async def get_report(self, session_id: str):
+        """Get comprehensive session report."""
+        try:
+            return await self.client.get_session_report(session_id)
+        except Exception as e:
+            self.app.notify(f"Error getting report: {e}", severity="error")
+            return None
+    
+    async def get_cost(self, session_id: str) -> dict:
+        """Get session cost breakdown."""
+        try:
+            return await self.client.get_session_cost(session_id)
+        except Exception as e:
+            self.app.notify(f"Error getting cost: {e}", severity="error")
+            return {}
+    
+    async def get_metrics(self, session_id: str) -> dict:
+        """Get session metrics."""
+        try:
+            return await self.client.get_session_metrics(session_id)
+        except Exception as e:
+            self.app.notify(f"Error getting metrics: {e}", severity="error")
+            return {}

package/ranger-tui/ranger_tui/actions/task_actions.py

@@ -0,0 +1,107 @@
+"""
+Task action handlers.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ranger_tui.app import RangerApp
+    from ranger_tui.data import DataClient
+
+
+class TaskActions:
+    """Task-related actions."""
+    
+    def __init__(self, app: "RangerApp"):
+        self.app = app
+        self.client: "DataClient" = app.client
+    
+    async def create(
+        self,
+        session_id: str,
+        task_type: str,
+        description: str,
+        prompt: str,
+        provider: str = "claude",
+        model: str = "claude-sonnet",
+    ) -> str | None:
+        """Create a new task."""
+        try:
+            task = await self.client.create_task(
+                session_id=session_id,
+                task_type=task_type,
+                description=description,
+                prompt=prompt,
+                provider=provider,
+                model=model,
+            )
+            self.app.notify(f"Created task: {task.id}", severity="information")
+            return task.id
+        except Exception as e:
+            self.app.notify(f"Failed to create task: {e}", severity="error")
+            return None
+    
+    async def queue(self, task_id: str) -> bool:
+        """Queue a task for execution."""
+        try:
+            success = await self.client.queue_task(task_id)
+            if success:
+                self.app.notify(f"Queued task: {task_id}", severity="information")
+            else:
+                self.app.notify("Failed to queue task (may not be pending)", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error queuing task: {e}", severity="error")
+            return False
+    
+    async def cancel(self, task_id: str) -> bool:
+        """Cancel a task."""
+        try:
+            success = await self.client.cancel_task(task_id)
+            if success:
+                self.app.notify(f"Cancelled task: {task_id}", severity="warning")
+            else:
+                self.app.notify("Failed to cancel task (may already be completed)", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error cancelling task: {e}", severity="error")
+            return False
+    
+    async def retry(self, task_id: str) -> bool:
+        """Retry a failed task."""
+        try:
+            success = await self.client.retry_task(task_id)
+            if success:
+                self.app.notify(f"Retrying task: {task_id}", severity="information")
+            else:
+                self.app.notify("Failed to retry task (may not be failed)", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error retrying task: {e}", severity="error")
+            return False
+    
+    async def complete(
+        self,
+        task_id: str,
+        content: str,
+        artifacts: list[str] | None = None,
+    ) -> bool:
+        """Mark a task as completed."""
+        try:
+            success = await self.client.complete_task(task_id, content, artifacts)
+            if success:
+                self.app.notify(f"Completed task: {task_id}", severity="information")
+            else:
+                self.app.notify("Failed to complete task", severity="error")
+            return success
+        except Exception as e:
+            self.app.notify(f"Error completing task: {e}", severity="error")
+            return False
+    
+    async def get_status(self, task_id: str):
+        """Get task status."""
+        try:
+            return await self.client.get_task(task_id)
+        except Exception as e:
+            self.app.notify(f"Error getting task: {e}", severity="error")
+            return None

package/ranger-tui/ranger_tui/app.py

@@ -0,0 +1,93 @@
+"""
+Main Ranger TUI Application.
+"""
+
+from textual.app import App
+from textual.binding import Binding
+from textual.reactive import reactive
+
+from ranger_tui.config import config
+from ranger_tui.data import DataClient, get_client, Session
+from ranger_tui.theme import RANGER_THEME
+from ranger_tui.screens import DashboardScreen
+
+
+class RangerApp(App):
+    """
+    Anastops Ranger TUI - Terminal dashboard for orchestration management.
+    
+    Navigation:
+    - Arrow keys to move
+    - Enter to select/open
+    - Escape to go back
+    - q to quit
+    """
+    
+    TITLE = "Ranger"
+    CSS_PATH = "styles/ranger.tcss"
+    
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True, priority=True),
+        Binding("escape", "back", "Back", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+    ]
+    
+    # Reactive state
+    sessions: reactive[list[Session]] = reactive(list, init=False)
+    mongo_connected: reactive[bool] = reactive(False)
+    redis_connected: reactive[bool] = reactive(False)
+    
+    def __init__(self):
+        super().__init__()
+        self.client: DataClient = get_client()
+    
+    async def on_mount(self) -> None:
+        """Called when app is mounted."""
+        # Register and apply custom theme
+        self.register_theme(RANGER_THEME)
+        self.theme = "ranger"
+        
+        # Connect to databases
+        await self._connect()
+        
+        # Start periodic refresh
+        self.set_interval(config.refresh_interval, self._refresh_data)
+        await self._refresh_data()
+        
+        # Push initial screen
+        await self.push_screen(DashboardScreen())
+    
+    async def _connect(self) -> None:
+        """Connect to MongoDB and Redis."""
+        await self.client.connect()
+        health = await self.client.health_check()
+        self.mongo_connected = health.get("mongodb", False)
+        self.redis_connected = health.get("redis", False)
+    
+    async def _refresh_data(self) -> None:
+        """Refresh data from databases."""
+        if not self.client.is_connected:
+            await self._connect()
+        
+        if self.client.is_connected:
+            self.sessions = await self.client.get_sessions()
+            
+            # Update connection status
+            health = await self.client.health_check()
+            self.mongo_connected = health.get("mongodb", False)
+            self.redis_connected = health.get("redis", False)
+    
+    def action_quit(self) -> None:
+        """Quit the application."""
+        self.exit()
+    
+    async def action_refresh(self) -> None:
+        """Manually refresh data."""
+        await self._refresh_data()
+        self.notify("Refreshed")
+    
+    def action_back(self) -> None:
+        """Go back to previous screen (but not from dashboard)."""
+        # Don't pop if we're on the dashboard (root screen)
+        if len(self.screen_stack) > 2:
+            self.pop_screen()

package/ranger-tui/ranger_tui/config.py

@@ -0,0 +1,100 @@
+"""
+Configuration management for Ranger TUI.
+Automatically loads credentials from ~/.anastops/.env or docker/.env file.
+"""
+
+import os
+from pathlib import Path
+from dataclasses import dataclass
+from dotenv import load_dotenv
+
+
+def _find_env_file() -> Path | None:
+    """Find the .env file, checking ~/.anastops first, then docker/.env."""
+    # Priority 1: User's anastops home directory (created by anastops init)
+    anastops_home = Path.home() / ".anastops" / ".env"
+    if anastops_home.exists():
+        return anastops_home
+    
+    # Priority 2: docker/.env in project directory tree
+    candidates = [
+        Path.cwd() / "docker" / ".env",
+        Path.cwd().parent / "docker" / ".env",
+        Path.cwd().parent.parent / "docker" / ".env",
+        Path(__file__).parent.parent.parent.parent.parent.parent / "docker" / ".env",
+    ]
+    
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    
+    return None
+
+
+def _load_env_file() -> None:
+    """Load environment variables from .env file."""
+    env_file = _find_env_file()
+    if env_file:
+        load_dotenv(env_file)
+
+
+# Load environment on module import
+_load_env_file()
+
+
+def _build_redis_url() -> str:
+    """Build Redis URL from environment variables."""
+    # Check for explicit REDIS_URL first
+    if redis_url := os.getenv("REDIS_URL"):
+        return redis_url
+    
+    # Build from components
+    password = os.getenv("REDIS_PASSWORD", "")
+    host = os.getenv("REDIS_HOST", "localhost")
+    port = os.getenv("REDIS_PORT", "6380")
+    
+    if password:
+        return f"redis://:{password}@{host}:{port}"
+    return f"redis://{host}:{port}"
+
+
+def _build_mongodb_url() -> str:
+    """Build MongoDB URL from environment variables."""
+    # Check for explicit MONGODB_URL first
+    if mongodb_url := os.getenv("MONGODB_URL"):
+        return mongodb_url
+    
+    # Build from components
+    username = os.getenv("MONGO_ROOT_USERNAME", "admin")
+    password = os.getenv("MONGO_ROOT_PASSWORD", "")
+    host = os.getenv("MONGO_HOST", "localhost")
+    port = os.getenv("MONGO_PORT", "27018")
+    database = os.getenv("MONGO_DATABASE", "anastops")
+    
+    if password:
+        return f"mongodb://{username}:{password}@{host}:{port}/{database}?authSource=admin"
+    return f"mongodb://{host}:{port}/{database}"
+
+
+@dataclass
+class Config:
+    """Application configuration loaded from environment variables."""
+    
+    mongodb_url: str
+    redis_url: str
+    refresh_interval: float
+    environment: str
+    
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Load configuration from environment variables."""
+        return cls(
+            mongodb_url=_build_mongodb_url(),
+            redis_url=_build_redis_url(),
+            refresh_interval=float(os.getenv("RANGER_REFRESH_INTERVAL", "2.0")),
+            environment=os.getenv("RANGER_ENVIRONMENT", "local"),
+        )
+
+
+# Global config instance
+config = Config.from_env()

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

@@ -0,0 +1,16 @@
+"""
+Data layer for Ranger TUI.
+"""
+
+from .client import DataClient, get_client
+from .models import Session, Task, Agent, Artifact, SessionReport
+
+__all__ = [
+    "DataClient",
+    "get_client",
+    "Session",
+    "Task",
+    "Agent",
+    "Artifact",
+    "SessionReport",
+]