empathy-framework 4.9.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

empathy_os/dashboard/standalone_server.py

@@ -0,0 +1,536 @@
+"""Standalone Dashboard Server - Reads Directly from Redis.
+
+This version bypasses the telemetry API layer and reads directly from Redis.
+Works with data populated by scripts/populate_redis_direct.py.
+
+Zero external dependencies (uses Python stdlib only).
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+try:
+    import redis
+
+    REDIS_AVAILABLE = True
+except ImportError:
+    REDIS_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+
+class StandaloneDashboardHandler(BaseHTTPRequestHandler):
+    """HTTP handler that reads directly from Redis."""
+
+    # Class variable for Redis connection (shared across requests)
+    _redis_client = None
+
+    @classmethod
+    def get_redis(cls):
+        """Get or create Redis connection."""
+        if not REDIS_AVAILABLE:
+            return None
+
+        if cls._redis_client is None:
+            try:
+                cls._redis_client = redis.Redis(host="localhost", port=6379, decode_responses=False)
+                cls._redis_client.ping()  # Test connection
+            except Exception as e:
+                logger.error(f"Failed to connect to Redis: {e}")
+                cls._redis_client = None
+
+        return cls._redis_client
+
+    def do_GET(self):
+        """Handle GET requests."""
+        parsed = urlparse(self.path)
+        path = parsed.path
+        query = parse_qs(parsed.query)
+
+        # Route requests
+        if path == "/" or path == "/index.html":
+            self.serve_file("index.html", "text/html")
+        elif path == "/static/style.css":
+            self.serve_file("style.css", "text/css")
+        elif path == "/static/app.js":
+            self.serve_file("app.js", "application/javascript")
+        elif path == "/api/health":
+            self.api_health()
+        elif path == "/api/agents":
+            self.api_agents()
+        elif path.startswith("/api/agents/"):
+            agent_id = path.split("/")[-1]
+            self.api_agent_detail(agent_id)
+        elif path == "/api/signals":
+            limit = int(query.get("limit", [50])[0])
+            self.api_signals(limit)
+        elif path == "/api/events":
+            event_type = query.get("event_type", [None])[0]
+            limit = int(query.get("limit", [100])[0])
+            self.api_events(event_type, limit)
+        elif path == "/api/approvals":
+            self.api_approvals()
+        elif path == "/api/feedback/workflows":
+            self.api_feedback_workflows()
+        elif path == "/api/feedback/underperforming":
+            threshold = float(query.get("threshold", [0.7])[0])
+            self.api_underperforming(threshold)
+        else:
+            self.send_error(404, "Not Found")
+
+    def do_POST(self):
+        """Handle POST requests."""
+        parsed = urlparse(self.path)
+        path = parsed.path
+
+        # Get request body
+        content_length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(content_length) if content_length > 0 else b"{}"
+        data = json.loads(body.decode("utf-8")) if body else {}
+
+        # Route requests
+        if "/approve" in path:
+            request_id = path.split("/")[-2]
+            self.api_approve(request_id, data.get("reason", "Approved via dashboard"))
+        elif "/reject" in path:
+            request_id = path.split("/")[-2]
+            self.api_reject(request_id, data.get("reason", "Rejected via dashboard"))
+        else:
+            self.send_error(404, "Not Found")
+
+    def serve_file(self, filename: str, content_type: str):
+        """Serve static file."""
+        try:
+            static_dir = Path(__file__).parent / "static"
+            file_path = static_dir / filename
+
+            if not file_path.exists():
+                self.send_error(404, f"File not found: {filename}")
+                return
+
+            content = file_path.read_bytes()
+
+            self.send_response(200)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(content)))
+            self.end_headers()
+            self.wfile.write(content)
+
+        except Exception as e:
+            logger.error(f"Failed to serve file {filename}: {e}")
+            self.send_error(500, str(e))
+
+    def send_json(self, data: dict | list, status: int = 200):
+        """Send JSON response."""
+        try:
+            content = json.dumps(data).encode("utf-8")
+
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(content)))
+            self.send_header("Access-Control-Allow-Origin", "*")  # CORS
+            self.end_headers()
+            self.wfile.write(content)
+
+        except Exception as e:
+            logger.error(f"Failed to send JSON: {e}")
+            self.send_error(500, str(e))
+
+    # ========================================================================
+    # API Endpoints - Read Directly from Redis
+    # ========================================================================
+
+    def api_health(self):
+        """System health endpoint."""
+        try:
+            r = self.get_redis()
+            has_redis = r is not None
+
+            if has_redis:
+                # Count keys directly
+                heartbeat_count = len(r.keys(b"heartbeat:*"))
+                approval_count = len(r.keys(b"approval:pending:*"))
+            else:
+                heartbeat_count = 0
+                approval_count = 0
+
+            self.send_json(
+                {
+                    "status": "healthy" if has_redis else "degraded",
+                    "redis_available": has_redis,
+                    "active_agents": heartbeat_count,
+                    "pending_approvals": approval_count,
+                    "timestamp": datetime.utcnow().isoformat(),
+                }
+            )
+        except Exception as e:
+            self.send_json({"status": "error", "error": str(e)}, status=500)
+
+    def api_agents(self):
+        """List active agents."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            result = []
+            for key in r.keys(b"heartbeat:*"):
+                try:
+                    data = r.get(key)
+                    if data:
+                        heartbeat = json.loads(data.decode("utf-8"))
+                        result.append(
+                            {
+                                "agent_id": heartbeat.get("agent_id"),
+                                "status": heartbeat.get("status"),
+                                "last_seen": heartbeat.get("timestamp"),
+                                "progress": heartbeat.get("progress", 0.0),
+                                "current_task": heartbeat.get("current_task", "Unknown"),
+                            }
+                        )
+                except Exception as e:
+                    logger.error(f"Failed to parse heartbeat {key}: {e}")
+
+            self.send_json(result)
+        except Exception as e:
+            logger.error(f"Failed to get agents: {e}")
+            self.send_json([], status=500)
+
+    def api_agent_detail(self, agent_id: str):
+        """Get specific agent details."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json({"error": "Redis not available"}, status=503)
+                return
+
+            key = f"heartbeat:{agent_id}".encode()
+            data = r.get(key)
+
+            if not data:
+                self.send_json({"error": f"Agent {agent_id} not found"}, status=404)
+                return
+
+            heartbeat = json.loads(data.decode("utf-8"))
+            self.send_json(
+                {
+                    "agent_id": heartbeat.get("agent_id"),
+                    "status": heartbeat.get("status"),
+                    "last_seen": heartbeat.get("timestamp"),
+                    "progress": heartbeat.get("progress", 0.0),
+                    "current_task": heartbeat.get("current_task"),
+                    "metadata": heartbeat.get("metadata", {}),
+                }
+            )
+        except Exception as e:
+            self.send_json({"error": str(e)}, status=500)
+
+    def api_signals(self, limit: int):
+        """Get recent coordination signals."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            result = []
+            for key in r.keys(b"empathy:signal:*")[:limit]:
+                try:
+                    data = r.get(key)
+                    if data:
+                        signal = json.loads(data.decode("utf-8"))
+                        result.append(
+                            {
+                                "signal_type": signal.get("signal_type"),
+                                "source_agent": signal.get("source_agent"),
+                                "target_agent": signal.get("target_agent"),
+                                "timestamp": signal.get("timestamp"),
+                                "payload": signal.get("payload", {}),
+                            }
+                        )
+                except Exception as e:
+                    logger.error(f"Failed to parse signal {key}: {e}")
+
+            # Sort by timestamp (newest first)
+            result.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            self.send_json(result[:limit])
+        except Exception as e:
+            logger.error(f"Failed to get signals: {e}")
+            self.send_json([])
+
+    def api_events(self, event_type: str | None, limit: int):
+        """Get recent events."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            result = []
+
+            # Get from streams
+            stream_patterns = [
+                b"stream:workflow_progress",
+                b"stream:agent_heartbeat",
+                b"stream:coordination_signal",
+            ]
+
+            for stream_key in stream_patterns:
+                try:
+                    # Get last N entries from stream
+                    entries = r.xrevrange(stream_key, count=limit)
+                    for entry_id, fields in entries:
+                        if b"data" in fields:
+                            event = json.loads(fields[b"data"].decode("utf-8"))
+                            result.append(
+                                {
+                                    "event_id": event.get("event_id"),
+                                    "event_type": event.get("event_type"),
+                                    "timestamp": event.get("timestamp"),
+                                    "data": event.get("data", {}),
+                                    "source": event.get("source"),
+                                }
+                            )
+                except Exception as e:
+                    logger.debug(f"Stream {stream_key} not found or empty: {e}")
+
+            # Sort by timestamp
+            result.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            self.send_json(result[:limit])
+        except Exception as e:
+            logger.error(f"Failed to get events: {e}")
+            self.send_json([])
+
+    def api_approvals(self):
+        """Get pending approvals."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            result = []
+            for key in r.keys(b"approval:pending:*"):
+                try:
+                    data = r.get(key)
+                    if data:
+                        approval = json.loads(data.decode("utf-8"))
+                        result.append(
+                            {
+                                "request_id": approval.get("request_id"),
+                                "approval_type": approval.get("approval_type"),
+                                "agent_id": approval.get("agent_id"),
+                                "context": approval.get("context", {}),
+                                "timestamp": approval.get("timestamp"),
+                                "timeout_seconds": approval.get("timeout_seconds", 300),
+                            }
+                        )
+                except Exception as e:
+                    logger.error(f"Failed to parse approval {key}: {e}")
+
+            self.send_json(result)
+        except Exception as e:
+            logger.error(f"Failed to get approvals: {e}")
+            self.send_json([])
+
+    def api_approve(self, request_id: str, reason: str):
+        """Approve request."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json({"error": "Redis not available"}, status=503)
+                return
+
+            # Delete from pending
+            key = f"approval:pending:{request_id}".encode()
+            if r.delete(key):
+                self.send_json({"status": "approved", "request_id": request_id})
+            else:
+                self.send_json({"error": "Request not found"}, status=404)
+        except Exception as e:
+            self.send_json({"error": str(e)}, status=500)
+
+    def api_reject(self, request_id: str, reason: str):
+        """Reject request."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json({"error": "Redis not available"}, status=503)
+                return
+
+            # Delete from pending
+            key = f"approval:pending:{request_id}".encode()
+            if r.delete(key):
+                self.send_json({"status": "rejected", "request_id": request_id})
+            else:
+                self.send_json({"error": "Request not found"}, status=404)
+        except Exception as e:
+            self.send_json({"error": str(e)}, status=500)
+
+    def api_feedback_workflows(self):
+        """Get workflow quality metrics."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            # Group feedback by workflow/stage/tier
+            feedback_groups = {}
+
+            for key in r.keys(b"feedback:*"):
+                try:
+                    data = r.get(key)
+                    if data:
+                        feedback = json.loads(data.decode("utf-8"))
+                        workflow = feedback.get("workflow_name")
+                        stage = feedback.get("stage_name")
+                        tier = feedback.get("tier")
+                        quality = feedback.get("quality_score")
+
+                        group_key = f"{workflow}/{stage}/{tier}"
+                        if group_key not in feedback_groups:
+                            feedback_groups[group_key] = {
+                                "workflow_name": workflow,
+                                "stage_name": stage,
+                                "tier": tier,
+                                "qualities": [],
+                            }
+                        feedback_groups[group_key]["qualities"].append(quality)
+                except Exception as e:
+                    logger.error(f"Failed to parse feedback {key}: {e}")
+
+            # Calculate stats
+            result = []
+            for group_key, group in feedback_groups.items():
+                qualities = group["qualities"]
+                if qualities:
+                    avg_quality = sum(qualities) / len(qualities)
+                    result.append(
+                        {
+                            "workflow_name": group["workflow_name"],
+                            "stage_name": group["stage_name"],
+                            "tier": group["tier"],
+                            "avg_quality": avg_quality,
+                            "sample_count": len(qualities),
+                            "trend": 0,  # Simplified - no trend calculation
+                        }
+                    )
+
+            self.send_json(result)
+        except Exception as e:
+            logger.error(f"Failed to get quality metrics: {e}")
+            self.send_json([])
+
+    def api_underperforming(self, threshold: float):
+        """Get underperforming stages."""
+        try:
+            r = self.get_redis()
+            if not r:
+                self.send_json([])
+                return
+
+            # Get all feedback and group by workflow/stage
+            feedback_groups = {}
+
+            for key in r.keys(b"feedback:*"):
+                try:
+                    data = r.get(key)
+                    if data:
+                        feedback = json.loads(data.decode("utf-8"))
+                        workflow = feedback.get("workflow_name")
+                        stage = feedback.get("stage_name")
+                        quality = feedback.get("quality_score")
+
+                        group_key = f"{workflow}/{stage}"
+                        if group_key not in feedback_groups:
+                            feedback_groups[group_key] = {
+                                "workflow_name": workflow,
+                                "stage_name": stage,
+                                "qualities": [],
+                            }
+                        feedback_groups[group_key]["qualities"].append(quality)
+                except Exception as e:
+                    logger.error(f"Failed to parse feedback {key}: {e}")
+
+            # Find underperforming stages
+            result = []
+            for group_key, group in feedback_groups.items():
+                qualities = group["qualities"]
+                if qualities:
+                    avg_quality = sum(qualities) / len(qualities)
+                    if avg_quality < threshold:
+                        result.append(
+                            {
+                                "workflow_name": group["workflow_name"],
+                                "stage_name": group["stage_name"],
+                                "avg_quality": avg_quality,
+                                "sample_count": len(qualities),
+                                "min_quality": min(qualities),
+                                "max_quality": max(qualities),
+                                "trend": 0,
+                            }
+                        )
+
+            # Sort by quality (worst first)
+            result.sort(key=lambda x: x["avg_quality"])
+            self.send_json(result)
+        except Exception as e:
+            logger.error(f"Failed to get underperforming: {e}")
+            self.send_json([])
+
+    def log_message(self, format, *args):
+        """Suppress default logging."""
+        # Override to reduce noise - only log errors
+        if args[1][0] in ("4", "5"):  # 4xx or 5xx errors
+            logger.warning(f"{self.address_string()} - {format % args}")
+
+
+def run_standalone_dashboard(host: str = "127.0.0.1", port: int = 8000):
+    """Run standalone dashboard that reads directly from Redis.
+
+    This version bypasses the telemetry API layer and works with
+    data populated by scripts/populate_redis_direct.py.
+
+    Args:
+        host: Host to bind to (default: 127.0.0.1)
+        port: Port to bind to (default: 8000)
+
+    Example:
+        >>> from empathy_os.dashboard.standalone_server import run_standalone_dashboard
+        >>> run_standalone_dashboard(host="0.0.0.0", port=8080)
+    """
+    if not REDIS_AVAILABLE:
+        print("⚠️  Warning: redis-py not installed. Install with: pip install redis")
+        print("   Dashboard will start but won't show data.")
+        print()
+
+    server = HTTPServer((host, port), StandaloneDashboardHandler)
+
+    print(f"🚀 Agent Coordination Dashboard (Standalone) running at http://{host}:{port}")
+    print(f"📊 Open in browser: http://{host}:{port}")
+    print()
+    print("💡 This version reads directly from Redis")
+    print("   Populate data with: python scripts/populate_redis_direct.py")
+    print()
+    print("Press Ctrl+C to stop")
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n\n🛑 Shutting down dashboard...")
+        server.shutdown()
+
+
+if __name__ == "__main__":
+    run_standalone_dashboard()

empathy_os/memory/__init__.py

@@ -123,17 +123,24 @@ from .security import (  # Audit Logging; PII Scrubbing; Secrets Detection
     Severity,
     detect_secrets,
 )
-from .short_term import (
+from .short_term import RedisShortTermMemory
+
+# Conversation Summary Index
+from .summary_index import AgentContext, ConversationSummaryIndex
+
+# Types (extracted to types.py for cleaner separation)
+from .types import (
     AccessTier,
     AgentCredentials,
     ConflictContext,
-    RedisShortTermMemory,
+    PaginatedResult,
+    RedisConfig,
+    RedisMetrics,
     StagedPattern,
+    TimeWindowQuery,
     TTLStrategy,
 )
-
-# Conversation Summary Index
-from .summary_index import AgentContext, ConversationSummaryIndex
+from .types import SecurityError as ShortTermSecurityError
 
 # Unified memory interface
 from .unified import Environment, MemoryConfig, UnifiedMemory
@@ -180,6 +187,8 @@ __all__ = [
     "MemoryStats",
     "Node",
     "NodeType",
+    # Pagination and Query Types
+    "PaginatedResult",
     "PIIDetection",
     "PIIPattern",
     # Security - PII
@@ -187,6 +196,9 @@ __all__ = [
     "PatternMetadata",
     "PatternNode",
     "PerformanceNode",
+    # Redis Configuration and Metrics
+    "RedisConfig",
+    "RedisMetrics",
     # Short-term Memory
     "RedisShortTermMemory",
     "RedisStartMethod",
@@ -203,8 +215,10 @@ __all__ = [
     "SessionInfo",
     "SessionType",
     "Severity",
+    "ShortTermSecurityError",
     "StagedPattern",
     "TTLStrategy",
+    "TimeWindowQuery",
     # Unified Memory Interface (recommended)
     "UnifiedMemory",
     "VulnerabilityNode",

empathy_os/memory/short_term.py

@@ -107,7 +107,7 @@ class RedisShortTermMemory:
     PREFIX_WORKING = "empathy:working:"
     PREFIX_STAGED = "empathy:staged:"
     PREFIX_CONFLICT = "empathy:conflict:"
-    PREFIX_COORDINATION = "empathy:coord:"
+    # PREFIX_COORDINATION removed in v5.0 - use empathy_os.telemetry.CoordinationSignals
     PREFIX_SESSION = "empathy:session:"
     PREFIX_PUBSUB = "empathy:pubsub:"
     PREFIX_STREAM = "empathy:stream:"
@@ -920,75 +920,9 @@ class RedisShortTermMemory:
         return True
 
     # === Coordination Signals ===
-
-    def send_signal(
-        self,
-        signal_type: str,
-        data: Any,
-        credentials: AgentCredentials,
-        target_agent: str | None = None,
-    ) -> bool:
-        """Send coordination signal to other agents
-
-        Args:
-            signal_type: Type of signal (e.g., "ready", "blocking", "complete")
-            data: Signal payload
-            credentials: Must be CONTRIBUTOR or higher
-            target_agent: Specific agent to signal (None = broadcast)
-
-        Returns:
-            True if sent
-
-        """
-        if not credentials.can_stage():
-            raise PermissionError(
-                f"Agent {credentials.agent_id} cannot send signals. "
-                "Requires CONTRIBUTOR tier or higher.",
-            )
-
-        target = target_agent or "broadcast"
-        key = f"{self.PREFIX_COORDINATION}{signal_type}:{credentials.agent_id}:{target}"
-        payload = {
-            "signal_type": signal_type,
-            "from_agent": credentials.agent_id,
-            "to_agent": target_agent,
-            "data": data,
-            "sent_at": datetime.now().isoformat(),
-        }
-        return self._set(key, json.dumps(payload), TTLStrategy.COORDINATION.value)
-
-    def receive_signals(
-        self,
-        credentials: AgentCredentials,
-        signal_type: str | None = None,
-    ) -> list[dict]:
-        """Receive coordination signals
-
-        Args:
-            credentials: Agent receiving signals
-            signal_type: Filter by signal type (optional)
-
-        Returns:
-            List of signals
-
-        """
-        if signal_type:
-            pattern = f"{self.PREFIX_COORDINATION}{signal_type}:*:{credentials.agent_id}"
-        else:
-            pattern = f"{self.PREFIX_COORDINATION}*:{credentials.agent_id}"
-
-        # Also get broadcasts
-        broadcast_pattern = f"{self.PREFIX_COORDINATION}*:*:broadcast"
-
-        keys = set(self._keys(pattern)) | set(self._keys(broadcast_pattern))
-        signals = []
-
-        for key in keys:
-            raw = self._get(key)
-            if raw:
-                signals.append(json.loads(raw))
-
-        return signals
+    # REMOVED in v5.0 - Use empathy_os.telemetry.CoordinationSignals instead
+    # - send_signal() → CoordinationSignals.signal()
+    # - receive_signals() → CoordinationSignals.get_pending_signals()
 
     # === Session Management ===