@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/multi_agent_orchestrator/src/vds_multi_agent_orchestrator/progress_dashboard.py

@@ -1,380 +0,0 @@
-"""Real-time progress dashboard for multi-agent coordination."""
-
-import asyncio
-import logging
-from datetime import UTC, datetime
-from typing import Any
-
-from rich.console import Console
-from rich.layout import Layout
-from rich.live import Live
-from rich.panel import Panel
-from rich.table import Table
-
-from .models import TaskStatusEnum
-from .redis_client import get_redis_client
-from .task_tracking import TaskTracker
-
-logger = logging.getLogger(__name__)
-
-
-class ProgressDashboard:
-    """Real-time progress dashboard for multi-agent workflows."""
-
-    def __init__(self):
-        self.console = Console()
-        self.task_tracker = TaskTracker()
-        self._redis = None
-        self._update_interval = 5  # seconds
-
-    async def initialize(self):
-        """Initialize dashboard components."""
-        await self.task_tracker.initialize()
-        self._redis = await get_redis_client()
-
-    def create_workflow_table(self, workflows: list[dict[str, Any]]) -> Table:
-        """Create workflow status table."""
-
-        table = Table(title="Workflow Status", show_header=True, header_style="bold magenta")
-        table.add_column("Workflow ID", style="cyan", no_wrap=True)
-        table.add_column("Pattern", style="green")
-        table.add_column("Status", style="yellow")
-        table.add_column("Progress", style="blue")
-        table.add_column("Tasks", style="white")
-        table.add_column("Duration", style="grey50")
-
-        for workflow in workflows:
-            workflow_id = workflow["workflow_id"]
-            pattern = workflow["pattern"]
-            status = workflow["status"]
-            progress = workflow["overall_progress"]
-            total_tasks = workflow["total_tasks"]
-            completed_tasks = workflow["completed_tasks"]
-
-            # Calculate duration
-            created_at = datetime.fromisoformat(workflow["created_at"].replace("Z", "+00:00"))
-            if workflow.get("completed_at"):
-                completed_at = datetime.fromisoformat(
-                    workflow["completed_at"].replace("Z", "+00:00")
-                )
-                duration = str(completed_at - created_at).split(".")[0]
-            else:
-                duration = str(datetime.now(UTC) - created_at).split(".")[0]
-
-            # Status styling
-            if status == "completed":
-                status_display = f"[green]{status}[/green]"
-            elif status == "active":
-                status_display = f"[yellow]{status}[/yellow]"
-            else:
-                status_display = f"[red]{status}[/red]"
-
-            # Progress bar
-            progress_bar = (
-                f"[{'█' * int(progress * 20)}{'░' * (20 - int(progress * 20))}] {progress:.1%}"
-            )
-
-            table.add_row(
-                workflow_id[-12:],  # Show last 12 chars
-                pattern,
-                status_display,
-                progress_bar,
-                f"{completed_tasks}/{total_tasks}",
-                duration,
-            )
-
-        return table
-
-    def create_agent_table(self, agent_workloads: list[dict[str, Any]]) -> Table:
-        """Create agent workload table."""
-
-        table = Table(title="Agent Workloads", show_header=True, header_style="bold cyan")
-        table.add_column("Agent ID", style="cyan", no_wrap=True)
-        table.add_column("Status", style="green")
-        table.add_column("Active Tasks", style="yellow")
-        table.add_column("Completed", style="blue")
-        table.add_column("Failed", style="red")
-        table.add_column("Success Rate", style="white")
-        table.add_column("Load", style="grey50")
-
-        for workload in agent_workloads:
-            agent_id = workload["agent_id"]
-            active_tasks = workload["active_tasks"]
-            completed_tasks = workload["completed_tasks"]
-            failed_tasks = workload["failed_tasks"]
-            success_rate = workload["success_rate"]
-            current_load = workload["current_load"]
-
-            # Determine agent status
-            if active_tasks > 0:
-                status = "[yellow]BUSY[/yellow]"
-            elif completed_tasks > 0:
-                status = "[green]AVAILABLE[/green]"
-            else:
-                status = "[grey50]IDLE[/grey50]"
-
-            # Load indicator
-            if current_load == 0:
-                load_indicator = "[green]●[/green] Light"
-            elif current_load <= 2:
-                load_indicator = "[yellow]●[/yellow] Medium"
-            else:
-                load_indicator = "[red]●[/red] Heavy"
-
-            table.add_row(
-                agent_id,
-                status,
-                str(active_tasks),
-                str(completed_tasks),
-                str(failed_tasks),
-                f"{success_rate:.1%}",
-                load_indicator,
-            )
-
-        return table
-
-    def create_task_details_table(self, workflows: list[dict[str, Any]]) -> Table:
-        """Create detailed task status table."""
-
-        table = Table(title="Task Details", show_header=True, header_style="bold yellow")
-        table.add_column("Task ID", style="cyan", no_wrap=True)
-        table.add_column("Service", style="green")
-        table.add_column("Type", style="blue")
-        table.add_column("Status", style="yellow")
-        table.add_column("Progress", style="white")
-        table.add_column("Agent", style="magenta")
-
-        for workflow in workflows:
-            for task_id, task_info in workflow["task_statuses"].items():
-                status = task_info["status"]
-                progress = task_info["progress"]
-                assigned_agent = task_info.get("assigned_agent", "")
-                service_id = task_info.get("service_id", "")
-                task_type = task_info.get("task_type", "")
-
-                # Status styling
-                if status == TaskStatusEnum.COMPLETED:
-                    status_display = f"[green]{status}[/green]"
-                elif status == TaskStatusEnum.IN_PROGRESS:
-                    status_display = f"[yellow]{status}[/yellow]"
-                elif status == TaskStatusEnum.FAILED:
-                    status_display = f"[red]{status}[/red]"
-                else:
-                    status_display = f"[grey50]{status}[/grey50]"
-
-                # Progress bar
-                progress_bar = (
-                    f"[{'█' * int(progress * 10)}{'░' * (10 - int(progress * 10))}] {progress:.0%}"
-                )
-
-                table.add_row(
-                    task_id[-15:],  # Show last 15 chars
-                    service_id[-20:] if service_id else "",
-                    task_type,
-                    status_display,
-                    progress_bar,
-                    assigned_agent[-10:] if assigned_agent else "",
-                )
-
-        return table
-
-    def create_summary_panel(self, dashboard_data: dict[str, Any]) -> Panel:
-        """Create summary statistics panel."""
-
-        session_id = dashboard_data["session_id"]
-        overall_progress = dashboard_data["overall_progress"]
-        total_workflows = dashboard_data["total_workflows"]
-        total_tasks = dashboard_data["total_tasks"]
-        completed_tasks = dashboard_data["completed_tasks"]
-        active_agents = dashboard_data["active_agents"]
-
-        summary_text = f"""
-[bold cyan]Session:[/bold cyan] {session_id}
-[bold green]Overall Progress:[/bold green] {overall_progress:.1%}
-[bold blue]Workflows:[/bold blue] {total_workflows}
-[bold yellow]Tasks:[/bold yellow] {completed_tasks}/{total_tasks}
-[bold magenta]Active Agents:[/bold magenta] {active_agents}
-[bold white]Updated:[/bold white] {datetime.now().strftime("%H:%M:%S")}
-        """.strip()
-
-        return Panel(summary_text, title="Multi-Agent Session Summary", border_style="green")
-
-    async def display_dashboard(self, session_id: str, duration_seconds: int | None = None):
-        """Display real-time dashboard for a session."""
-
-        await self.initialize()
-
-        start_time = datetime.now()
-
-        with Live(console=self.console, refresh_per_second=1) as live:
-            while True:
-                try:
-                    # Get dashboard data
-                    dashboard_data = await self.task_tracker.create_progress_dashboard(session_id)
-
-                    if not dashboard_data["workflows"]:
-                        live.update(
-                            Panel(
-                                "No workflows found for session",
-                                title="Dashboard",
-                                border_style="red",
-                            )
-                        )
-                        await asyncio.sleep(self._update_interval)
-                        continue
-
-                    # Create layout
-                    layout = Layout()
-
-                    # Create components
-                    summary_panel = self.create_summary_panel(dashboard_data)
-                    workflow_table = self.create_workflow_table(dashboard_data["workflows"])
-                    agent_table = self.create_agent_table(dashboard_data["agent_workloads"])
-                    task_table = self.create_task_details_table(dashboard_data["workflows"])
-
-                    # Arrange layout
-                    layout.split_column(
-                        Layout(summary_panel, size=8),
-                        Layout().split_row(Layout(workflow_table), Layout(agent_table)),
-                        Layout(task_table),
-                    )
-
-                    live.update(layout)
-
-                    # Check if all workflows are completed
-                    all_completed = all(
-                        w["status"] == "completed" for w in dashboard_data["workflows"]
-                    )
-                    if all_completed:
-                        self.console.print("\n[bold green]✅ All workflows completed![/bold green]")
-                        break
-
-                    # Check duration limit
-                    if (
-                        duration_seconds
-                        and (datetime.now() - start_time).seconds >= duration_seconds
-                    ):
-                        self.console.print(
-                            f"\n[yellow]⏰ Dashboard duration limit ({duration_seconds}s) reached[/yellow]"
-                        )
-                        break
-
-                    await asyncio.sleep(self._update_interval)
-
-                except KeyboardInterrupt:
-                    self.console.print("\n[yellow]Dashboard stopped by user[/yellow]")
-                    break
-                except Exception as e:
-                    logger.exception(f"Dashboard error: {e}")
-                    live.update(Panel(f"Error: {e}", title="Dashboard Error", border_style="red"))
-                    await asyncio.sleep(self._update_interval)
-
-    async def generate_completion_report(self, session_id: str) -> dict[str, Any]:
-        """Generate comprehensive completion report."""
-
-        await self.initialize()
-
-        dashboard_data = await self.task_tracker.create_progress_dashboard(session_id)
-
-        # Calculate detailed metrics
-        total_duration = timedelta()
-        task_type_stats = {}
-        agent_performance = {}
-
-        for workflow in dashboard_data["workflows"]:
-            # Workflow duration
-            if workflow.get("completed_at"):
-                created_at = datetime.fromisoformat(workflow["created_at"].replace("Z", "+00:00"))
-                completed_at = datetime.fromisoformat(
-                    workflow["completed_at"].replace("Z", "+00:00")
-                )
-                total_duration += completed_at - created_at
-
-            # Task type statistics
-            for _task_id, task_info in workflow["task_statuses"].items():
-                task_type = task_info.get("task_type", "unknown")
-                if task_type not in task_type_stats:
-                    task_type_stats[task_type] = {"total": 0, "completed": 0, "failed": 0}
-
-                task_type_stats[task_type]["total"] += 1
-                if task_info["status"] == TaskStatusEnum.COMPLETED:
-                    task_type_stats[task_type]["completed"] += 1
-                elif task_info["status"] == TaskStatusEnum.FAILED:
-                    task_type_stats[task_type]["failed"] += 1
-
-        # Agent performance
-        for workload in dashboard_data["agent_workloads"]:
-            agent_id = workload["agent_id"]
-            agent_performance[agent_id] = {
-                "total_tasks": workload["total_assigned"],
-                "completed_tasks": workload["completed_tasks"],
-                "failed_tasks": workload["failed_tasks"],
-                "success_rate": workload["success_rate"],
-            }
-
-        return {
-            "session_id": session_id,
-            "report_generated_at": datetime.now(UTC).isoformat(),
-            "overall_metrics": {
-                "total_workflows": dashboard_data["total_workflows"],
-                "total_tasks": dashboard_data["total_tasks"],
-                "completed_tasks": dashboard_data["completed_tasks"],
-                "overall_progress": dashboard_data["overall_progress"],
-                "total_duration_hours": total_duration.total_seconds() / 3600,
-                "active_agents": len(agent_performance),
-            },
-            "task_type_statistics": task_type_stats,
-            "agent_performance": agent_performance,
-            "workflows": dashboard_data["workflows"],
-        }
-
-    def print_completion_report(self, report: dict[str, Any]):
-        """Print formatted completion report."""
-
-        self.console.print("\n[bold green]🎉 Multi-Agent Session Completion Report[/bold green]")
-        self.console.print("=" * 60)
-
-        # Overall metrics
-        metrics = report["overall_metrics"]
-        self.console.print("\n[bold cyan]Overall Metrics:[/bold cyan]")
-        self.console.print(f"  Total Workflows: {metrics['total_workflows']}")
-        self.console.print(f"  Total Tasks: {metrics['total_tasks']}")
-        self.console.print(f"  Completed Tasks: {metrics['completed_tasks']}")
-        self.console.print(f"  Overall Progress: {metrics['overall_progress']:.1%}")
-        self.console.print(f"  Total Duration: {metrics['total_duration_hours']:.2f} hours")
-        self.console.print(f"  Active Agents: {metrics['active_agents']}")
-
-        # Task type statistics
-        self.console.print("\n[bold yellow]Task Type Statistics:[/bold yellow]")
-        for task_type, stats in report["task_type_statistics"].items():
-            success_rate = stats["completed"] / stats["total"] if stats["total"] > 0 else 0
-            self.console.print(
-                f"  {task_type}: {stats['completed']}/{stats['total']} ({success_rate:.1%})"
-            )
-
-        # Agent performance
-        self.console.print("\n[bold magenta]Agent Performance:[/bold magenta]")
-        for agent_id, perf in report["agent_performance"].items():
-            self.console.print(
-                f"  {agent_id}: {perf['completed_tasks']}/{perf['total_tasks']} ({perf['success_rate']:.1%})"
-            )
-
-        self.console.print("\n[bold green]✅ Report Complete[/bold green]")
-
-
-async def main_dashboard(session_id: str, duration: int | None = None):
-    """Main function to run the dashboard."""
-    dashboard = ProgressDashboard()
-    await dashboard.display_dashboard(session_id, duration)
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) < 2:
-        sys.exit(1)
-
-    session_id = sys.argv[1]
-    duration = int(sys.argv[2]) if len(sys.argv) > 2 else None
-
-    asyncio.run(main_dashboard(session_id, duration))

package/tools/vds-scripts/multi_agent_orchestrator/src/vds_multi_agent_orchestrator/redis_client.py

@@ -1,245 +0,0 @@
-"""Redis client for multi-agent coordination."""
-
-import asyncio
-import json
-import logging
-from typing import Any
-
-import redis.asyncio as redis
-from redis.asyncio.lock import Lock
-
-from .config import get_settings
-
-logger = logging.getLogger(__name__)
-
-
-class RedisClient:
-    """Async Redis client for multi-agent coordination."""
-
-    def __init__(self):
-        self.settings = get_settings()
-        self._client: redis.Redis | None = None
-        self._connection_pool: redis.ConnectionPool | None = None
-
-    async def connect(self):
-        """Initialize Redis connection."""
-        if self._client is not None:
-            return
-
-        self._connection_pool = redis.ConnectionPool(
-            host=self.settings.redis_host,
-            port=self.settings.redis_port,
-            db=self.settings.redis_db,
-            password=self.settings.redis_password,
-            decode_responses=True,
-            max_connections=20,
-        )
-
-        self._client = redis.Redis(connection_pool=self._connection_pool)
-
-        # Test connection
-        try:
-            await self._client.ping()
-            logger.info(
-                f"Connected to Redis at {self.settings.redis_host}:{self.settings.redis_port}"
-            )
-        except Exception as e:
-            logger.exception(f"Failed to connect to Redis: {e}")
-            raise
-
-    async def disconnect(self):
-        """Close Redis connection."""
-        if self._client:
-            await self._client.close()
-            self._client = None
-
-        if self._connection_pool:
-            await self._connection_pool.disconnect()
-            self._connection_pool = None
-
-    @property
-    def client(self) -> redis.Redis:
-        """Get Redis client instance."""
-        if self._client is None:
-            raise RuntimeError("Redis client not connected. Call connect() first.")
-        return self._client
-
-    # Task Queue Operations
-    async def lpush(self, key: str, *values) -> int:
-        """Push values to the left of a list."""
-        return await self.client.lpush(key, *values)
-
-    async def rpop(self, key: str) -> str | None:
-        """Pop value from the right of a list."""
-        return await self.client.rpop(key)
-
-    async def lrem(self, key: str, count: int, value: str) -> int:
-        """Remove elements from a list."""
-        return await self.client.lrem(key, count, value)
-
-    async def llen(self, key: str) -> int:
-        """Get length of a list."""
-        return await self.client.llen(key)
-
-    async def lrange(self, key: str, start: int, end: int) -> list[str]:
-        """Get range of elements from a list."""
-        return await self.client.lrange(key, start, end)
-
-    # Hash Operations
-    async def hset(self, key: str, mapping: dict[str, Any]) -> int:
-        """Set hash fields."""
-        # Convert all values to strings for Redis
-        str_mapping = {
-            k: json.dumps(v) if isinstance(v, (dict, list)) else str(v) for k, v in mapping.items()
-        }
-        return await self.client.hset(key, mapping=str_mapping)
-
-    async def hget(self, key: str, field: str) -> str | None:
-        """Get hash field value."""
-        return await self.client.hget(key, field)
-
-    async def hgetall(self, key: str) -> dict[str, str]:
-        """Get all hash fields and values."""
-        return await self.client.hgetall(key)
-
-    async def hdel(self, key: str, *fields) -> int:
-        """Delete hash fields."""
-        return await self.client.hdel(key, *fields)
-
-    async def hexists(self, key: str, field: str) -> bool:
-        """Check if hash field exists."""
-        return await self.client.hexists(key, field)
-
-    # Set Operations
-    async def sadd(self, key: str, *values) -> int:
-        """Add members to a set."""
-        return await self.client.sadd(key, *values)
-
-    async def srem(self, key: str, *values) -> int:
-        """Remove members from a set."""
-        return await self.client.srem(key, *values)
-
-    async def smembers(self, key: str) -> set:
-        """Get all members of a set."""
-        return await self.client.smembers(key)
-
-    async def sismember(self, key: str, value: str) -> bool:
-        """Check if value is a member of a set."""
-        return await self.client.sismember(key, value)
-
-    # Key Operations
-    async def exists(self, key: str) -> bool:
-        """Check if key exists."""
-        return await self.client.exists(key) > 0
-
-    async def delete(self, *keys) -> int:
-        """Delete keys."""
-        return await self.client.delete(*keys)
-
-    async def keys(self, pattern: str) -> list[str]:
-        """Get keys matching pattern."""
-        return await self.client.keys(pattern)
-
-    async def expire(self, key: str, seconds: int) -> bool:
-        """Set key expiration."""
-        return await self.client.expire(key, seconds)
-
-    async def ttl(self, key: str) -> int:
-        """Get key time to live."""
-        return await self.client.ttl(key)
-
-    # String Operations
-    async def set(self, key: str, value: str, ex: int | None = None, nx: bool = False) -> bool:
-        """Set key value with optional expiration and nx flag."""
-        return await self.client.set(key, value, ex=ex, nx=nx)
-
-    async def get(self, key: str) -> str | None:
-        """Get key value."""
-        return await self.client.get(key)
-
-    # Pub/Sub Operations
-    async def publish(self, channel: str, message: str) -> int:
-        """Publish message to channel."""
-        return await self.client.publish(channel, message)
-
-    async def subscribe(self, *channels) -> redis.client.PubSub:
-        """Subscribe to channels."""
-        pubsub = self.client.pubsub()
-        await pubsub.subscribe(*channels)
-        return pubsub
-
-    # Lock Operations
-    def lock(
-        self, key: str, timeout: int | None = None, blocking_timeout: int | None = None
-    ) -> Lock:
-        """Create a distributed lock."""
-        return Lock(
-            self.client,
-            key,
-            timeout=timeout or self.settings.file_lock_timeout_minutes * 60,
-            blocking_timeout=blocking_timeout,
-        )
-
-    # Atomic Operations
-    async def atomic_increment(self, key: str, amount: int = 1) -> int:
-        """Atomically increment a counter."""
-        return await self.client.incrby(key, amount)
-
-    async def atomic_decrement(self, key: str, amount: int = 1) -> int:
-        """Atomically decrement a counter."""
-        return await self.client.decrby(key, amount)
-
-    # Batch Operations
-    async def pipeline_execute(self, operations: list[tuple]) -> list[Any]:
-        """Execute multiple operations in a pipeline."""
-        pipe = self.client.pipeline()
-
-        for op_name, args, kwargs in operations:
-            method = getattr(pipe, op_name)
-            method(*args, **kwargs)
-
-        return await pipe.execute()
-
-    # Health Check
-    async def health_check(self) -> dict[str, Any]:
-        """Perform Redis health check."""
-        try:
-            start_time = asyncio.get_event_loop().time()
-            await self.client.ping()
-            latency = (asyncio.get_event_loop().time() - start_time) * 1000
-
-            info = await self.client.info()
-
-            return {
-                "status": "healthy",
-                "latency_ms": round(latency, 2),
-                "connected_clients": info.get("connected_clients", 0),
-                "used_memory": info.get("used_memory_human", "unknown"),
-                "redis_version": info.get("redis_version", "unknown"),
-            }
-        except Exception as e:
-            return {"status": "unhealthy", "error": str(e)}
-
-
-# Global Redis client instance
-_redis_client: RedisClient | None = None
-
-
-async def get_redis_client() -> RedisClient:
-    """Get global Redis client instance."""
-    global _redis_client
-
-    if _redis_client is None:
-        _redis_client = RedisClient()
-        await _redis_client.connect()
-
-    return _redis_client
-
-
-async def close_redis_client():
-    """Close global Redis client."""
-    global _redis_client
-
-    if _redis_client is not None:
-        await _redis_client.disconnect()
-        _redis_client = None