devloop 0.2.0__py3-none-any.whl

devloop/core/feedback.py

@@ -0,0 +1,311 @@
+"""Feedback system for agent behavior learning."""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+import aiofiles
+
+
+class FeedbackType(Enum):
+    """Types of feedback that can be given to agents."""
+
+    THUMBS_UP = "thumbs_up"
+    THUMBS_DOWN = "thumbs_down"
+    RATING = "rating"  # 1-5 stars
+    COMMENT = "comment"
+    DISMISS = "dismiss"  # User dismissed/ignored the agent's action
+
+
+@dataclass
+class Feedback:
+    """Individual feedback item."""
+
+    id: str
+    agent_name: str
+    event_type: str
+    feedback_type: FeedbackType
+    value: Any  # thumbs_up/down: bool, rating: int 1-5, comment: str, dismiss: None
+    comment: Optional[str] = None
+    context: Optional[Dict[str, Any]] = None  # Agent result data, file info, etc.
+    timestamp: Optional[float] = None
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = time.time()
+
+        # Validate feedback values
+        if self.feedback_type == FeedbackType.RATING:
+            if not isinstance(self.value, int) or not (1 <= self.value <= 5):
+                raise ValueError("Rating must be an integer between 1 and 5")
+        elif self.feedback_type in (FeedbackType.THUMBS_UP, FeedbackType.THUMBS_DOWN):
+            if not isinstance(self.value, bool):
+                raise ValueError("Thumbs feedback must be a boolean")
+        elif self.feedback_type == FeedbackType.COMMENT:
+            if not isinstance(self.value, str):
+                raise ValueError("Comment feedback must be a string")
+        elif self.feedback_type == FeedbackType.DISMISS:
+            if self.value is not None:
+                raise ValueError("Dismiss feedback value must be None")
+
+
+@dataclass
+class AgentPerformance:
+    """Aggregated performance metrics for an agent."""
+
+    agent_name: str
+    total_executions: int = 0
+    successful_executions: int = 0
+    average_duration: float = 0.0
+    feedback_count: int = 0
+    thumbs_up_count: int = 0
+    thumbs_down_count: int = 0
+    average_rating: float = 0.0
+    last_updated: Optional[float] = None
+
+    def __post_init__(self):
+        if self.last_updated is None:
+            self.last_updated = time.time()
+
+
+class FeedbackStore:
+    """Persistent storage for agent feedback and performance data."""
+
+    def __init__(self, storage_path: Path):
+        self.storage_path = storage_path
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+        self.feedback_file = storage_path / "feedback.jsonl"
+        self.performance_file = storage_path / "performance.json"
+
+    async def store_feedback(self, feedback: Feedback) -> None:
+        """Store a feedback item."""
+        feedback_dict = {
+            "id": feedback.id,
+            "agent_name": feedback.agent_name,
+            "event_type": feedback.event_type,
+            "feedback_type": feedback.feedback_type.value,
+            "value": feedback.value,
+            "comment": feedback.comment,
+            "context": feedback.context,
+            "timestamp": feedback.timestamp,
+        }
+
+        async with aiofiles.open(self.feedback_file, "a") as f:
+            await f.write(json.dumps(feedback_dict) + "\n")
+
+    async def get_feedback_for_agent(
+        self, agent_name: str, limit: int = 100
+    ) -> List[Feedback]:
+        """Get recent feedback for a specific agent."""
+        feedback_items: List[Feedback] = []
+
+        if not self.feedback_file.exists():
+            return feedback_items
+
+        async with aiofiles.open(self.feedback_file, "r") as f:
+            lines = await f.readlines()
+
+        # Parse feedback items for this agent
+        for line in reversed(lines):  # Most recent first
+            if len(feedback_items) >= limit:
+                break
+
+            try:
+                data = json.loads(line.strip())
+                if data["agent_name"] == agent_name:
+                    feedback_items.append(
+                        Feedback(
+                            id=data["id"],
+                            agent_name=data["agent_name"],
+                            event_type=data["event_type"],
+                            feedback_type=FeedbackType(data["feedback_type"]),
+                            value=data["value"],
+                            comment=data["comment"],
+                            context=data["context"],
+                            timestamp=data["timestamp"],
+                        )
+                    )
+            except (json.JSONDecodeError, KeyError):
+                continue
+
+        return feedback_items
+
+    async def update_performance(
+        self, agent_name: str, success: bool, duration: float
+    ) -> None:
+        """Update performance metrics for an agent."""
+        performance = await self.get_performance(agent_name)
+
+        performance.total_executions += 1
+        if success:
+            performance.successful_executions += 1
+
+        # Update rolling average duration
+        if performance.total_executions == 1:
+            performance.average_duration = duration
+        else:
+            performance.average_duration = (
+                (performance.average_duration * (performance.total_executions - 1))
+                + duration
+            ) / performance.total_executions
+
+        performance.last_updated = time.time()
+
+        await self._save_performance(performance)
+
+    async def update_performance_with_feedback(
+        self, agent_name: str, feedback: Feedback
+    ) -> None:
+        """Update performance metrics with feedback data."""
+        performance = await self.get_performance(agent_name)
+
+        performance.feedback_count += 1
+
+        if feedback.feedback_type == FeedbackType.THUMBS_UP and feedback.value:
+            performance.thumbs_up_count += 1
+        elif feedback.feedback_type == FeedbackType.THUMBS_DOWN and feedback.value:
+            performance.thumbs_down_count += 1
+        elif feedback.feedback_type == FeedbackType.RATING:
+            # Update rolling average rating
+            if performance.feedback_count == 1:
+                performance.average_rating = feedback.value
+            else:
+                performance.average_rating = (
+                    (performance.average_rating * (performance.feedback_count - 1))
+                    + feedback.value
+                ) / performance.feedback_count
+
+        performance.last_updated = time.time()
+
+        await self._save_performance(performance)
+
+    async def get_performance(self, agent_name: str) -> AgentPerformance:
+        """Get performance metrics for an agent."""
+        if not self.performance_file.exists():
+            return AgentPerformance(agent_name=agent_name)
+
+        async with aiofiles.open(self.performance_file, "r") as f:
+            content = await f.read()
+
+        try:
+            data = json.loads(content)
+            agent_data = data.get(agent_name, {})
+            return AgentPerformance(
+                agent_name=agent_name,
+                total_executions=agent_data.get("total_executions", 0),
+                successful_executions=agent_data.get("successful_executions", 0),
+                average_duration=agent_data.get("average_duration", 0.0),
+                feedback_count=agent_data.get("feedback_count", 0),
+                thumbs_up_count=agent_data.get("thumbs_up_count", 0),
+                thumbs_down_count=agent_data.get("thumbs_down_count", 0),
+                average_rating=agent_data.get("average_rating", 0.0),
+                last_updated=agent_data.get("last_updated", time.time()),
+            )
+        except (json.JSONDecodeError, KeyError):
+            return AgentPerformance(agent_name=agent_name)
+
+    async def _save_performance(self, performance: AgentPerformance) -> None:
+        """Save performance data to disk."""
+        # Load existing data
+        data = {}
+        if self.performance_file.exists():
+            async with aiofiles.open(self.performance_file, "r") as f:
+                content = await f.read()
+            try:
+                data = json.loads(content)
+            except json.JSONDecodeError:
+                data = {}
+
+        # Update with new performance data
+        data[performance.agent_name] = {
+            "total_executions": performance.total_executions,
+            "successful_executions": performance.successful_executions,
+            "average_duration": performance.average_duration,
+            "feedback_count": performance.feedback_count,
+            "thumbs_up_count": performance.thumbs_up_count,
+            "thumbs_down_count": performance.thumbs_down_count,
+            "average_rating": performance.average_rating,
+            "last_updated": performance.last_updated,
+        }
+
+        # Save back to file
+        async with aiofiles.open(self.performance_file, "w") as f:
+            await f.write(json.dumps(data, indent=2))
+
+
+class FeedbackAPI:
+    """API for collecting and managing feedback."""
+
+    def __init__(self, feedback_store: FeedbackStore):
+        self.feedback_store = feedback_store
+
+    async def submit_feedback(
+        self,
+        agent_name: str,
+        event_type: str,
+        feedback_type: FeedbackType,
+        value: Any,
+        comment: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Submit feedback for an agent."""
+        feedback = Feedback(
+            id=str(uuid4()),
+            agent_name=agent_name,
+            event_type=event_type,
+            feedback_type=feedback_type,
+            value=value,
+            comment=comment,
+            context=context,
+        )
+
+        await self.feedback_store.store_feedback(feedback)
+        await self.feedback_store.update_performance_with_feedback(agent_name, feedback)
+
+        return feedback.id
+
+    async def get_agent_insights(self, agent_name: str) -> Dict[str, Any]:
+        """Get insights about an agent's performance and feedback."""
+        performance = await self.feedback_store.get_performance(agent_name)
+        recent_feedback = await self.feedback_store.get_feedback_for_agent(
+            agent_name, limit=20
+        )
+
+        success_rate = (
+            (performance.successful_executions / performance.total_executions * 100)
+            if performance.total_executions > 0
+            else 0
+        )
+
+        thumbs_up_rate = (
+            (performance.thumbs_up_count / performance.feedback_count * 100)
+            if performance.feedback_count > 0
+            else 0
+        )
+
+        return {
+            "agent_name": agent_name,
+            "performance": {
+                "total_executions": performance.total_executions,
+                "success_rate": round(success_rate, 1),
+                "average_duration": round(performance.average_duration, 2),
+                "feedback_count": performance.feedback_count,
+                "thumbs_up_rate": round(thumbs_up_rate, 1),
+                "average_rating": round(performance.average_rating, 1),
+            },
+            "recent_feedback": [
+                {
+                    "type": f.feedback_type.value,
+                    "value": f.value,
+                    "comment": f.comment,
+                    "timestamp": f.timestamp,
+                }
+                for f in recent_feedback[:5]  # Last 5 feedback items
+            ],
+        }

devloop/core/learning.py

@@ -0,0 +1,351 @@
+"""Agent behavior learning system for Phase 3."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import aiofiles
+
+
+@dataclass
+class BehaviorPattern:
+    """A learned behavior pattern for an agent."""
+
+    agent_name: str
+    pattern_name: str
+    description: str
+    conditions: Dict[str, Any]
+    recommended_action: str
+    confidence: float  # 0.0 to 1.0
+    frequency: int = 1
+    last_observed: Optional[float] = None
+
+
+class LearningSystem:
+    """System for learning from agent behavior and feedback."""
+
+    def __init__(self, storage_path: Path):
+        """Initialize learning system.
+
+        Args:
+            storage_path: Path to store learning data
+        """
+        self.storage_path = storage_path
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+        self.patterns_file = storage_path / "patterns.json"
+        self.insights_file = storage_path / "insights.json"
+
+    async def learn_pattern(
+        self,
+        agent_name: str,
+        pattern_name: str,
+        description: str,
+        conditions: Dict[str, Any],
+        recommended_action: str,
+        confidence: float = 0.8,
+    ) -> None:
+        """Learn a behavior pattern from agent execution.
+
+        Args:
+            agent_name: Name of the agent
+            pattern_name: Name of the pattern
+            description: Description of the pattern
+            conditions: Conditions that trigger the pattern
+            recommended_action: Recommended action for this pattern
+            confidence: Confidence level (0.0-1.0)
+        """
+        patterns = await self._load_patterns()
+
+        key = f"{agent_name}:{pattern_name}"
+        if key in patterns:
+            # Update existing pattern
+            pattern = patterns[key]
+            pattern["frequency"] += 1
+            pattern["confidence"] = min(1.0, pattern["confidence"] + 0.05)
+        else:
+            # Create new pattern
+            import time
+
+            pattern = {
+                "agent_name": agent_name,
+                "pattern_name": pattern_name,
+                "description": description,
+                "conditions": conditions,
+                "recommended_action": recommended_action,
+                "confidence": confidence,
+                "frequency": 1,
+                "last_observed": time.time(),
+            }
+
+        patterns[key] = pattern
+        await self._save_patterns(patterns)
+
+    async def get_patterns_for_agent(self, agent_name: str) -> List[BehaviorPattern]:
+        """Get learned patterns for an agent.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            List of learned behavior patterns
+        """
+        patterns_data = await self._load_patterns()
+        patterns = []
+
+        for key, data in patterns_data.items():
+            if data.get("agent_name") == agent_name:
+                patterns.append(
+                    BehaviorPattern(
+                        agent_name=data["agent_name"],
+                        pattern_name=data["pattern_name"],
+                        description=data["description"],
+                        conditions=data["conditions"],
+                        recommended_action=data["recommended_action"],
+                        confidence=data["confidence"],
+                        frequency=data.get("frequency", 1),
+                        last_observed=data.get("last_observed"),
+                    )
+                )
+
+        return sorted(patterns, key=lambda p: p.confidence, reverse=True)
+
+    async def get_recommendations(self, agent_name: str) -> List[Dict[str, Any]]:
+        """Get recommendations based on learned patterns.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            List of recommendations
+        """
+        patterns = await self.get_patterns_for_agent(agent_name)
+        recommendations = []
+
+        for pattern in patterns:
+            if pattern.confidence >= 0.7:  # Only high-confidence patterns
+                recommendations.append(
+                    {
+                        "pattern": pattern.pattern_name,
+                        "description": pattern.description,
+                        "action": pattern.recommended_action,
+                        "confidence": pattern.confidence,
+                        "frequency": pattern.frequency,
+                    }
+                )
+
+        return recommendations
+
+    async def store_insight(
+        self,
+        agent_name: str,
+        insight_type: str,
+        data: Dict[str, Any],
+    ) -> None:
+        """Store an insight about agent behavior.
+
+        Args:
+            agent_name: Name of the agent
+            insight_type: Type of insight
+            data: Insight data
+        """
+        insights = await self._load_insights()
+
+        key = f"{agent_name}:{insight_type}"
+        if key in insights:
+            insights[key]["count"] += 1
+            insights[key]["latest_data"] = data
+        else:
+            import time
+
+            insights[key] = {
+                "agent_name": agent_name,
+                "insight_type": insight_type,
+                "data": data,
+                "latest_data": data,
+                "count": 1,
+                "first_observed": time.time(),
+                "last_observed": time.time(),
+            }
+
+        insights[key]["last_observed"] = __import__("time").time()
+        await self._save_insights(insights)
+
+    async def get_insights_for_agent(self, agent_name: str) -> Dict[str, Any]:
+        """Get all insights for an agent.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            Dictionary of insights
+        """
+        insights_data = await self._load_insights()
+        agent_insights = {}
+
+        for key, data in insights_data.items():
+            if data.get("agent_name") == agent_name:
+                insight_type = data["insight_type"]
+                agent_insights[insight_type] = {
+                    "count": data["count"],
+                    "data": data.get("latest_data", data.get("data", {})),
+                    "first_observed": data.get("first_observed"),
+                    "last_observed": data.get("last_observed"),
+                }
+
+        return agent_insights
+
+    async def suggest_optimization(self, agent_name: str) -> Optional[Dict[str, Any]]:
+        """Suggest optimizations for an agent based on learning.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            Optimization suggestion or None
+        """
+        insights = await self.get_insights_for_agent(agent_name)
+
+        # Analyze patterns
+        suggestions = []
+
+        if "slow_execution" in insights:
+            suggestions.append(
+                {
+                    "issue": "Slow execution detected",
+                    "suggestion": "Consider increasing debounce time or reducing scope",
+                    "priority": "medium",
+                }
+            )
+
+        if "high_memory_usage" in insights:
+            suggestions.append(
+                {
+                    "issue": "High memory usage",
+                    "suggestion": "Consider processing files in batches",
+                    "priority": "high",
+                }
+            )
+
+        if "frequent_errors" in insights:
+            suggestions.append(
+                {
+                    "issue": "Frequent errors",
+                    "suggestion": "Review error handling and edge cases",
+                    "priority": "high",
+                }
+            )
+
+        if suggestions:
+            return suggestions[0]
+
+        return None
+
+    async def _load_patterns(self) -> Dict[str, Dict[str, Any]]:
+        """Load all patterns from file.
+
+        Returns:
+            Dictionary of patterns
+        """
+        if not self.patterns_file.exists():
+            return {}
+
+        async with aiofiles.open(self.patterns_file, "r") as f:
+            content = await f.read()
+
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return {}
+
+    async def _save_patterns(self, patterns: Dict[str, Dict[str, Any]]) -> None:
+        """Save patterns to file.
+
+        Args:
+            patterns: Dictionary of patterns to save
+        """
+        async with aiofiles.open(self.patterns_file, "w") as f:
+            await f.write(json.dumps(patterns, indent=2))
+
+    async def _load_insights(self) -> Dict[str, Dict[str, Any]]:
+        """Load all insights from file.
+
+        Returns:
+            Dictionary of insights
+        """
+        if not self.insights_file.exists():
+            return {}
+
+        async with aiofiles.open(self.insights_file, "r") as f:
+            content = await f.read()
+
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            return {}
+
+    async def _save_insights(self, insights: Dict[str, Dict[str, Any]]) -> None:
+        """Save insights to file.
+
+        Args:
+            insights: Dictionary of insights to save
+        """
+        async with aiofiles.open(self.insights_file, "w") as f:
+            await f.write(json.dumps(insights, indent=2))
+
+
+class AdaptiveAgentConfig:
+    """Adaptive configuration that learns from behavior."""
+
+    def __init__(self, learning_system: LearningSystem, agent_name: str):
+        """Initialize adaptive config.
+
+        Args:
+            learning_system: Learning system instance
+            agent_name: Name of the agent
+        """
+        self.learning_system = learning_system
+        self.agent_name = agent_name
+        self._config_cache: Dict[str, Any] = {}
+
+    async def get_optimal_parameters(self) -> Dict[str, Any]:
+        """Get parameters optimized based on learning.
+
+        Returns:
+            Optimized configuration parameters
+        """
+        insights = await self.learning_system.get_insights_for_agent(self.agent_name)
+        parameters = {
+            "debounce_seconds": 1.0,
+            "timeout_seconds": 30,
+            "retry_count": 3,
+            "batch_size": 10,
+        }
+
+        # Adapt based on insights
+        if "slow_execution" in insights:
+            parameters["debounce_seconds"] = 2.0
+            parameters["batch_size"] = 5
+
+        if "frequent_errors" in insights:
+            parameters["retry_count"] = 5
+
+        return parameters
+
+    async def should_execute(self) -> bool:
+        """Determine if agent should execute based on learning.
+
+        Returns:
+            True if agent should execute
+        """
+        insights = await self.learning_system.get_insights_for_agent(self.agent_name)
+
+        # Skip if too many recent errors
+        if "frequent_errors" in insights:
+            error_count = insights["frequent_errors"]["count"]
+            if error_count > 10:
+                return False
+
+        return True