devloop 0.2.0__py3-none-any.whl

devloop/collectors/system.py

@@ -0,0 +1,195 @@
+"""System event collector using psutil for resource monitoring."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Dict, Optional
+
+try:
+    import psutil
+
+    HAS_PSUTIL = True
+except ImportError:
+    HAS_PSUTIL = False
+    psutil = None
+
+from devloop.collectors.base import BaseCollector
+
+
+class SystemCollector(BaseCollector):
+    """Collects system-related events like resource usage and idle time."""
+
+    def __init__(
+        self,
+        event_bus: Any,  # EventBus type (avoiding circular import)
+        config: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__("system", event_bus, config)
+
+        if not HAS_PSUTIL:
+            self.logger.warning("psutil not available - system monitoring disabled")
+            self._psutil_available = False
+        else:
+            self._psutil_available = True
+
+        # Configuration
+        self.check_interval = self.config.get("check_interval", 30)  # seconds
+        self.cpu_threshold = self.config.get("cpu_threshold", 80)  # percent
+        self.memory_threshold = self.config.get("memory_threshold", 85)  # percent
+        self.idle_threshold = self.config.get("idle_threshold", 300)  # seconds
+
+        # State tracking
+        self._last_cpu_percent = 0
+        self._last_memory_percent = 0
+        self._last_idle_time = time.time()
+        self._is_idle = False
+        self._monitoring_task: Optional[asyncio.Task] = None
+
+    def _get_system_stats(self) -> Dict[str, Any]:
+        """Get current system statistics."""
+        if not self._psutil_available:
+            return {}
+
+        try:
+            return {
+                "cpu_percent": psutil.cpu_percent(interval=1),
+                "memory_percent": psutil.virtual_memory().percent,
+                "memory_used": psutil.virtual_memory().used,
+                "memory_total": psutil.virtual_memory().total,
+                "disk_usage": psutil.disk_usage("/").percent,
+                "load_average": (
+                    psutil.getloadavg() if hasattr(psutil, "getloadavg") else None
+                ),
+                "timestamp": time.time(),
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting system stats: {e}")
+            return {}
+
+    async def _check_system_resources(self) -> None:
+        """Check system resources and emit events if thresholds are exceeded."""
+        if not self._psutil_available:
+            return
+
+        stats = self._get_system_stats()
+        if not stats:
+            return
+
+        # Check CPU usage
+        cpu_percent = stats["cpu_percent"]
+        if (
+            cpu_percent > self.cpu_threshold
+            and self._last_cpu_percent <= self.cpu_threshold
+        ):
+            await self._emit_event(
+                "system:high_cpu",
+                {
+                    "cpu_percent": cpu_percent,
+                    "threshold": self.cpu_threshold,
+                    "timestamp": stats["timestamp"],
+                },
+                "high",
+                "system",
+            )
+
+        self._last_cpu_percent = cpu_percent
+
+        # Check memory usage
+        memory_percent = stats["memory_percent"]
+        if (
+            memory_percent > self.memory_threshold
+            and self._last_memory_percent <= self.memory_threshold
+        ):
+            await self._emit_event(
+                "system:low_memory",
+                {
+                    "memory_percent": memory_percent,
+                    "memory_used": stats["memory_used"],
+                    "memory_total": stats["memory_total"],
+                    "threshold": self.memory_threshold,
+                    "timestamp": stats["timestamp"],
+                },
+                "critical",
+                "system",
+            )
+
+        self._last_memory_percent = memory_percent
+
+        # Check idle time (simplified - in a real implementation you'd use more sophisticated idle detection)
+        current_time = time.time()
+        # For demo purposes, consider system idle if no significant CPU usage for a period
+        if cpu_percent < 5:  # Very low CPU usage
+            if not self._is_idle:
+                idle_duration = current_time - self._last_idle_time
+                if idle_duration > self.idle_threshold:
+                    await self._emit_event(
+                        "system:idle",
+                        {"idle_duration": idle_duration, "timestamp": current_time},
+                        "normal",
+                        "system",
+                    )
+                    self._is_idle = True
+        else:
+            if self._is_idle:
+                await self._emit_event(
+                    "system:active", {"timestamp": current_time}, "normal", "system"
+                )
+                self._is_idle = False
+            self._last_idle_time = current_time
+
+    async def _monitor_system(self) -> None:
+        """Main monitoring loop."""
+        self.logger.info(
+            f"Starting system monitoring (interval: {self.check_interval}s)"
+        )
+
+        while self.is_running:
+            try:
+                await self._check_system_resources()
+                await asyncio.sleep(self.check_interval)
+            except Exception as e:
+                self.logger.error(f"Error in system monitoring loop: {e}")
+                await asyncio.sleep(self.check_interval)
+
+    async def start(self) -> None:
+        """Start the system collector."""
+        if self.is_running:
+            return
+
+        if not self._psutil_available:
+            self.logger.error("Cannot start system collector - psutil not available")
+            return
+
+        self._set_running(True)
+
+        # Start monitoring task
+        self._monitoring_task = asyncio.create_task(self._monitor_system())
+
+        # Emit initial system status
+        stats = self._get_system_stats()
+        if stats:
+            await self._emit_event("system:status", stats, "normal", "system")
+
+        self.logger.info("System collector started")
+
+    async def stop(self) -> None:
+        """Stop the system collector."""
+        if not self.is_running:
+            return
+
+        self._set_running(False)
+
+        # Cancel monitoring task
+        if self._monitoring_task:
+            self._monitoring_task.cancel()
+            try:
+                await self._monitoring_task
+            except asyncio.CancelledError:
+                pass
+
+        self.logger.info("System collector stopped")
+
+    async def emit_system_event(self, event_type: str, payload: Dict[str, Any]) -> None:
+        """Manually emit a system event (for testing or external triggers)."""
+        await self._emit_event(f"system:{event_type}", payload, "normal", "system")

devloop/core/__init__.py

@@ -0,0 +1,21 @@
+"""Core framework components."""
+
+from .agent import Agent, AgentResult
+from .config import Config, ConfigWrapper
+from .context_store import context_store
+from .event import Event, EventBus, Priority
+from .event_store import event_store
+from .manager import AgentManager
+
+__all__ = [
+    "Agent",
+    "AgentResult",
+    "Config",
+    "ConfigWrapper",
+    "context_store",
+    "Event",
+    "EventBus",
+    "event_store",
+    "Priority",
+    "AgentManager",
+]

devloop/core/agent.py

@@ -0,0 +1,206 @@
+"""Base agent class with performance monitoring and feedback support."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from .event import Event, EventBus
+from .feedback import FeedbackAPI
+from .performance import PerformanceMonitor
+
+
+@dataclass
+class AgentResult:
+    """Agent execution result."""
+
+    agent_name: str
+    success: bool
+    duration: float
+    message: str = ""
+    data: Dict[str, Any] | None = None
+    error: str | None = None
+
+    def __post_init__(self):
+        """Validate AgentResult parameters."""
+        # Validate agent_name
+        if not isinstance(self.agent_name, str):
+            raise TypeError(
+                f"agent_name must be a string, got {type(self.agent_name).__name__}"
+            )
+        if not self.agent_name:
+            raise ValueError("agent_name cannot be empty")
+
+        # Validate success
+        if not isinstance(self.success, bool):
+            raise TypeError(
+                f"success must be a boolean, got {type(self.success).__name__}"
+            )
+
+        # Validate duration
+        if not isinstance(self.duration, (int, float)):
+            raise TypeError(
+                f"duration must be a number, got {type(self.duration).__name__}. "
+                "Did you forget to include duration parameter in AgentResult creation?"
+            )
+        if self.duration < 0:
+            raise ValueError(f"duration must be non-negative, got {self.duration}")
+
+        # Validate message
+        if not isinstance(self.message, str):
+            raise TypeError(
+                f"message must be a string, got {type(self.message).__name__}"
+            )
+
+        # Validate data
+        if self.data is not None and not isinstance(self.data, dict):
+            raise TypeError(
+                f"data must be a dict or None, got {type(self.data).__name__}"
+            )
+
+        # Validate error
+        if self.error is not None and not isinstance(self.error, str):
+            raise TypeError(
+                f"error must be a string or None, got {type(self.error).__name__}"
+            )
+
+
+class Agent(ABC):
+    """Base agent class with performance monitoring and feedback."""
+
+    def __init__(
+        self,
+        name: str,
+        triggers: List[str],
+        event_bus: EventBus,
+        feedback_api: Optional[FeedbackAPI] = None,
+        performance_monitor: Optional[PerformanceMonitor] = None,
+    ):
+        self.name = name
+        self.triggers = triggers
+        self.event_bus = event_bus
+        self.feedback_api = feedback_api
+        self.performance_monitor = performance_monitor
+        self.enabled = True
+        self.logger = logging.getLogger(f"agent.{name}")
+        self._running = False
+        self._event_queue: asyncio.Queue[Event] = asyncio.Queue()
+
+    @abstractmethod
+    async def handle(self, event: Event) -> AgentResult:
+        """Handle an event. Must be implemented by subclasses."""
+        pass
+
+    async def start(self) -> None:
+        """Start the agent."""
+        if self._running:
+            return
+
+        self._running = True
+
+        # Subscribe to configured triggers
+        for trigger in self.triggers:
+            await self.event_bus.subscribe(trigger, self._event_queue)
+
+        # Start event processing loop
+        asyncio.create_task(self._process_events())
+        self.logger.info(f"Agent {self.name} started, listening to {self.triggers}")
+
+    async def stop(self) -> None:
+        """Stop the agent."""
+        if not self._running:
+            return
+
+        self._running = False
+
+        # Unsubscribe from events
+        for trigger in self.triggers:
+            await self.event_bus.unsubscribe(trigger, self._event_queue)
+
+        self.logger.info(f"Agent {self.name} stopped")
+
+    async def _process_events(self) -> None:
+        """Process events from the queue with performance monitoring."""
+        while self._running:
+            try:
+                # Wait for event with timeout to allow checking _running
+                event = await asyncio.wait_for(self._event_queue.get(), timeout=1.0)
+            except asyncio.TimeoutError:
+                continue
+
+            if not self.enabled:
+                continue
+
+            # Execute handler with performance monitoring
+            try:
+                operation_name = f"agent.{self.name}.handle"
+
+                if self.performance_monitor:
+                    async with self.performance_monitor.monitor_operation(
+                        operation_name,
+                        metadata={"event_type": event.type, "agent_name": self.name},
+                    ) as metrics:
+                        result = await self.handle(event)
+                        metrics.complete(result.success, result.error)
+
+                        # Update result duration from metrics
+                        if metrics.duration:
+                            result.duration = metrics.duration
+                else:
+                    start_time = time.time()
+                    result = await self.handle(event)
+                    result.duration = time.time() - start_time
+
+                # Update performance store if available
+                if self.feedback_api:
+                    await self.feedback_api.feedback_store.update_performance(
+                        self.name, result.success, result.duration
+                    )
+
+                # Publish result
+                await self._publish_result(result)
+
+                # Log result
+                status = "✓" if result.success else "✗"
+                self.logger.info(
+                    f"{status} {self.name}: {result.message} ({result.duration:.2f}s)"
+                )
+
+            except Exception as e:
+                self.logger.error(f"Error in {self.name}: {e}", exc_info=True)
+
+                error_result = AgentResult(
+                    agent_name=self.name,
+                    success=False,
+                    duration=0.1,  # Default duration for errors
+                    error=str(e),
+                )
+
+                # Update performance store for failed operations
+                if self.feedback_api:
+                    await self.feedback_api.feedback_store.update_performance(
+                        self.name, False, error_result.duration
+                    )
+
+                await self._publish_result(error_result)
+
+    async def _publish_result(self, result: AgentResult) -> None:
+        """Publish agent result as an event."""
+        await self.event_bus.emit(
+            Event(
+                type=f"agent:{self.name}:completed",
+                payload={
+                    "agent_name": result.agent_name,
+                    "success": result.success,
+                    "duration": result.duration,
+                    "message": result.message,
+                    "data": result.data,
+                    "error": result.error,
+                },
+                source=self.name,
+            )
+        )