attune-ai 2.1.4__py3-none-any.whl → 2.2.0__py3-none-any.whl

attune/cli_router.py

@@ -195,9 +195,7 @@ class HybridRouter:
         with open(self.preferences_path, "w") as f:
             yaml.dump(data, f, default_flow_style=False)
 
-    async def route(
-        self, user_input: str, context: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
+    async def route(self, user_input: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
         """Route user input to appropriate command or workflow.
 
         Args:
@@ -242,7 +240,8 @@ class HybridRouter:
             "args": args,
             "original": command,
             "confidence": 1.0,
-            "instruction": f"Use Skill tool with skill='{skill}'" + (f", args='{args}'" if args else ""),
+            "instruction": f"Use Skill tool with skill='{skill}'"
+            + (f", args='{args}'" if args else ""),
         }
 
     def _infer_command(self, keyword: str) -> dict[str, Any] | None:
@@ -271,7 +270,8 @@ class HybridRouter:
                 "original": keyword,
                 "confidence": pref.confidence,
                 "source": "learned",
-                "instruction": f"Use Skill tool with skill='{pref.skill}'" + (f", args='{pref.args}'" if pref.args else ""),
+                "instruction": f"Use Skill tool with skill='{pref.skill}'"
+                + (f", args='{pref.args}'" if pref.args else ""),
             }
 
         # Check built-in keyword map
@@ -284,7 +284,8 @@ class HybridRouter:
                 "original": keyword,
                 "confidence": 0.9,
                 "source": "builtin",
-                "instruction": f"Use Skill tool with skill='{skill}'" + (f", args='{args}'" if args else ""),
+                "instruction": f"Use Skill tool with skill='{skill}'"
+                + (f", args='{args}'" if args else ""),
             }
 
         # Check for hub names (show hub menu)
@@ -329,7 +330,8 @@ class HybridRouter:
             "reasoning": decision.reasoning,
             "original": text,
             "source": "natural_language",
-            "instruction": f"Use Skill tool with skill='{skill}'" + (f", args='{args}'" if args else ""),
+            "instruction": f"Use Skill tool with skill='{skill}'"
+            + (f", args='{args}'" if args else ""),
         }
 
     def _workflow_to_skill(self, workflow: str) -> tuple[str, str]:

attune/cli_unified.py

@@ -30,6 +30,9 @@ Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
 """
 
+# ruff: noqa: E402
+# Deprecation warning must be shown before other imports
+
 import warnings
 
 warnings.warn(

attune/core.py

@@ -25,6 +25,23 @@ if TYPE_CHECKING:
     from .pattern_library import PatternLibrary
 
 
+@dataclass
+class InteractionResponse:
+    """Response from an interaction with EmpathyOS.
+
+    Attributes:
+        level: Empathy level used (1-5)
+        response: The response text
+        confidence: Confidence score (0.0 to 1.0)
+        predictions: Optional list of predictions (for Level 4+)
+    """
+
+    level: int
+    response: str
+    confidence: float = 1.0
+    predictions: list[str] | None = None
+
+
 @dataclass
 class CollaborationState:
     """Stock & Flow model of AI-human collaboration
@@ -68,6 +85,11 @@ class CollaborationState:
         # Track trajectory
         self.trust_trajectory.append(self.trust_level)
 
+    @property
+    def current_level(self) -> float:
+        """Get current trust level (alias for trust_level)."""
+        return self.trust_level
+
 
 class EmpathyOS:
     """Empathy Operating System for AI-Human Collaboration.
@@ -130,6 +152,7 @@ class EmpathyOS:
         shared_library: PatternLibrary | None = None,
         short_term_memory: RedisShortTermMemory | None = None,
         access_tier: AccessTier = AccessTier.CONTRIBUTOR,
+        persistence_enabled: bool = True,
     ):
         """Initialize EmpathyOS
 
@@ -146,11 +169,13 @@ class EmpathyOS:
                               staging, and conflict resolution.
             access_tier: Access tier for this agent (Observer, Contributor, Validator, Steward).
                         Determines what operations the agent can perform on shared memory.
+            persistence_enabled: Whether to enable pattern/state persistence (default: True)
 
         """
         self.user_id = user_id
         self.target_level = target_level
         self.confidence_threshold = confidence_threshold
+        self.persistence_enabled = persistence_enabled
         self.logger = logger or logging.getLogger(__name__)
         self.shared_library = shared_library
 
@@ -1263,6 +1288,171 @@ class EmpathyOS:
         """Reset collaboration state (new session)"""
         self.collaboration_state = CollaborationState()
 
+    def interact(
+        self,
+        user_id: str,
+        user_input: str,
+        context: dict | None = None,
+    ) -> InteractionResponse:
+        """Process a user interaction and return a response.
+
+        This is a synchronous convenience method for simple interactions.
+        For full empathy level control, use the level_X_* async methods.
+
+        Args:
+            user_id: User identifier
+            user_input: The user's input text
+            context: Optional context dictionary
+
+        Returns:
+            InteractionResponse with level, response, confidence, and optional predictions
+
+        Example:
+            >>> empathy = EmpathyOS(user_id="dev_123")
+            >>> response = empathy.interact(
+            ...     user_id="dev_123",
+            ...     user_input="How do I optimize this query?",
+            ...     context={"domain": "database"}
+            ... )
+            >>> print(f"[L{response.level}] {response.response}")
+
+        """
+        context = context or {}
+
+        # Determine appropriate empathy level based on trust and context
+        current_trust = self.collaboration_state.trust_level
+        level = self._determine_interaction_level(current_trust, context)
+
+        # Generate response based on level
+        response_text = self._generate_response(user_input, context, level)
+
+        # For Level 4+, generate predictions
+        predictions = None
+        if level >= 4:
+            predictions = self._generate_predictions(user_input, context)
+
+        # Calculate confidence based on context completeness and trust
+        confidence = self._calculate_confidence(context, current_trust)
+
+        # Update interaction tracking
+        self.collaboration_state.total_interactions += 1
+        self.current_empathy_level = level
+
+        return InteractionResponse(
+            level=level,
+            response=response_text,
+            confidence=confidence,
+            predictions=predictions,
+        )
+
+    def record_success(self, success: bool) -> None:
+        """Record the outcome of an interaction for trust tracking.
+
+        Call this after receiving user feedback on whether an interaction
+        was helpful. Updates the collaboration state's trust level.
+
+        Args:
+            success: True if the interaction was helpful, False otherwise
+
+        Example:
+            >>> response = empathy.interact(...)
+            >>> # After getting user feedback
+            >>> feedback = input("Was this helpful? (y/n): ")
+            >>> empathy.record_success(success=(feedback.lower() == 'y'))
+            >>> print(f"Trust level: {empathy.collaboration_state.trust_level:.0%}")
+
+        """
+        outcome = "success" if success else "failure"
+        self.collaboration_state.update_trust(outcome)
+
+        self.logger.debug(
+            f"Recorded interaction outcome: {outcome}",
+            extra={
+                "user_id": self.user_id,
+                "success": success,
+                "new_trust_level": self.collaboration_state.trust_level,
+            },
+        )
+
+    def _determine_interaction_level(self, trust: float, context: dict) -> int:
+        """Determine appropriate empathy level for interaction.
+
+        Args:
+            trust: Current trust level (0.0 to 1.0)
+            context: Interaction context
+
+        Returns:
+            Empathy level (1-5)
+
+        """
+        # Start conservative, increase with trust
+        if trust < 0.3:
+            return 1  # Reactive only
+        elif trust < 0.5:
+            return 2  # Guided
+        elif trust < 0.7:
+            return min(3, self.target_level)  # Proactive
+        elif trust < 0.85:
+            return min(4, self.target_level)  # Anticipatory
+        else:
+            return min(5, self.target_level)  # Systems
+
+    def _generate_response(self, user_input: str, context: dict, level: int) -> str:
+        """Generate response based on empathy level.
+
+        **Extension Point**: Override this method to implement domain-specific
+        response generation (e.g., using LLMs, templates, or rule engines).
+
+        Args:
+            user_input: User's input text
+            context: Interaction context
+            level: Empathy level to use
+
+        Returns:
+            Response text
+
+        """
+        # Default implementation - override for real logic
+        level_descriptions = {
+            1: "Reactive response",
+            2: "Guided response with clarification",
+            3: "Proactive response anticipating needs",
+            4: "Anticipatory response predicting future needs",
+            5: "Systems-level response addressing root patterns",
+        }
+        return f"[Level {level}] {level_descriptions.get(level, 'Response')}: Processing '{user_input}'"
+
+    def _generate_predictions(self, user_input: str, context: dict) -> list[str]:
+        """Generate predictions for Level 4+ interactions.
+
+        **Extension Point**: Override to implement domain-specific prediction logic.
+
+        Args:
+            user_input: User's input text
+            context: Interaction context
+
+        Returns:
+            List of prediction strings
+
+        """
+        # Default implementation - override for real predictions
+        return ["Potential follow-up: Related topics may include..."]
+
+    def _calculate_confidence(self, context: dict, trust: float) -> float:
+        """Calculate confidence score for response.
+
+        Args:
+            context: Interaction context
+            trust: Current trust level
+
+        Returns:
+            Confidence score (0.0 to 1.0)
+
+        """
+        # Base confidence on context completeness and trust
+        context_score = min(1.0, len(context) * 0.1) if context else 0.5
+        return (context_score + trust) / 2
+
     # =========================================================================
     # SHORT-TERM MEMORY (Redis-backed Multi-Agent Coordination)
     # =========================================================================

attune/dashboard/app.py

@@ -377,7 +377,9 @@ async def get_underperforming_stages(threshold: float = 0.7):
         all_underperforming = []
 
         for workflow in workflows:
-            underperforming = feedback.get_underperforming_stages(workflow, quality_threshold=threshold)
+            underperforming = feedback.get_underperforming_stages(
+                workflow, quality_threshold=threshold
+            )
             for stage_name, stats in underperforming:
                 all_underperforming.append(
                     {
@@ -472,7 +474,7 @@ async def websocket_endpoint(websocket: WebSocket):
     try:
         while True:
             # Receive ping to keep connection alive
-            data = await websocket.receive_text()
+            _ = await websocket.receive_text()
 
             # Send updates (in production, this would stream from Redis)
             coordinator = HeartbeatCoordinator()

attune/dashboard/simple_server.py

@@ -378,7 +378,9 @@ class DashboardHandler(BaseHTTPRequestHandler):
             all_underperforming = []
 
             for workflow in workflows:
-                underperforming = feedback.get_underperforming_stages(workflow, quality_threshold=threshold)
+                underperforming = feedback.get_underperforming_stages(
+                    workflow, quality_threshold=threshold
+                )
                 for stage_name, stats in underperforming:
                     all_underperforming.append(
                         {

attune/dashboard/standalone_server.py

@@ -305,7 +305,11 @@ class StandaloneDashboardHandler(BaseHTTPRequestHandler):
 
                         result.append(
                             {
-                                "event_id": entry_id.decode("utf-8") if isinstance(entry_id, bytes) else entry_id,
+                                "event_id": (
+                                    entry_id.decode("utf-8")
+                                    if isinstance(entry_id, bytes)
+                                    else entry_id
+                                ),
                                 "event_type": event_type,
                                 "timestamp": timestamp,
                                 "data": data,
@@ -423,7 +427,7 @@ class StandaloneDashboardHandler(BaseHTTPRequestHandler):
 
             # Calculate stats
             result = []
-            for group_key, group in feedback_groups.items():
+            for _group_key, group in feedback_groups.items():
                 qualities = group["qualities"]
                 if qualities:
                     avg_quality = sum(qualities) / len(qualities)
@@ -476,7 +480,7 @@ class StandaloneDashboardHandler(BaseHTTPRequestHandler):
 
             # Find underperforming stages
             result = []
-            for group_key, group in feedback_groups.items():
+            for _group_key, group in feedback_groups.items():
                 qualities = group["qualities"]
                 if qualities:
                     avg_quality = sum(qualities) / len(qualities)