empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_llm_toolkit/core.py

@@ -1,5 +1,4 @@
-"""
-Empathy LLM - Core Wrapper
+"""Empathy LLM - Core Wrapper
 
 Main class that wraps any LLM provider with Empathy Framework levels.
 
@@ -7,6 +6,7 @@ Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
 """
 
+import asyncio
 import logging
 import time
 from typing import Any
@@ -22,16 +22,21 @@ from empathy_os.memory import (
 )
 
 from .levels import EmpathyLevel
-from .providers import AnthropicProvider, BaseLLMProvider, LocalProvider, OpenAIProvider
+from .providers import (
+    AnthropicProvider,
+    BaseLLMProvider,
+    GeminiProvider,
+    LocalProvider,
+    OpenAIProvider,
+)
 from .routing import ModelRouter
-from .state import CollaborationState, UserPattern
+from .state import CollaborationState, PatternType, UserPattern
 
 logger = logging.getLogger(__name__)
 
 
 class EmpathyLLM:
-    """
-    Wraps any LLM provider with Empathy Framework levels.
+    """Wraps any LLM provider with Empathy Framework levels.
 
     Automatically progresses from Level 1 (reactive) to Level 4 (anticipatory)
     based on user collaboration state.
@@ -85,6 +90,7 @@ class EmpathyLLM:
         ...     user_input="Design the architecture",
         ...     task_type="architectural_decision"
         ... )
+
     """
 
     def __init__(
@@ -101,8 +107,7 @@ class EmpathyLLM:
         enable_model_routing: bool = False,
         **kwargs,
     ):
-        """
-        Initialize EmpathyLLM.
+        """Initialize EmpathyLLM.
 
         Args:
             provider: "anthropic", "openai", or "local"
@@ -126,6 +131,7 @@ class EmpathyLLM:
                 - CAPABLE (Sonnet): code generation, bug fixes, security review
                 - PREMIUM (Opus): coordination, synthesis, architectural decisions
             **kwargs: Provider-specific options
+
         """
         self.target_level = target_level
         self.pattern_library = pattern_library or {}
@@ -157,7 +163,7 @@ class EmpathyLLM:
             self._cached_memory = self.claude_memory_loader.load_all_memory(project_root)
             logger.info(
                 f"EmpathyLLM initialized with Claude memory: "
-                f"{len(self._cached_memory)} chars loaded"
+                f"{len(self._cached_memory)} chars loaded",
             )
 
         # Initialize Phase 3 security controls (v1.8.0+)
@@ -173,7 +179,7 @@ class EmpathyLLM:
         logger.info(
             f"EmpathyLLM initialized: provider={provider}, target_level={target_level}, "
             f"security={'enabled' if enable_security else 'disabled'}, "
-            f"model_routing={'enabled' if enable_model_routing else 'disabled'}"
+            f"model_routing={'enabled' if enable_model_routing else 'disabled'}",
         )
 
     def _initialize_security(self):
@@ -207,24 +213,30 @@ class EmpathyLLM:
             logger.info(f"Audit Logger initialized: {audit_log_dir}")
 
     def _create_provider(
-        self, provider: str, api_key: str | None, model: str | None, **kwargs
+        self,
+        provider: str,
+        api_key: str | None,
+        model: str | None,
+        **kwargs,
     ) -> BaseLLMProvider:
         """Create appropriate provider instance"""
-
         if provider == "anthropic":
             return AnthropicProvider(
-                api_key=api_key, model=model or "claude-sonnet-4-5-20250929", **kwargs
+                api_key=api_key,
+                model=model or "claude-sonnet-4-5-20250929",
+                **kwargs,
             )
-        elif provider == "openai":
+        if provider == "openai":
             return OpenAIProvider(api_key=api_key, model=model or "gpt-4-turbo-preview", **kwargs)
-        elif provider == "local":
+        if provider in ("google", "gemini"):
+            return GeminiProvider(api_key=api_key, model=model or "gemini-1.5-pro", **kwargs)
+        if provider == "local":
             return LocalProvider(
                 endpoint=kwargs.get("endpoint", "http://localhost:11434"),
                 model=model or "llama2",
                 **kwargs,
             )
-        else:
-            raise ValueError(f"Unknown provider: {provider}")
+        raise ValueError(f"Unknown provider: {provider}")
 
     def _get_or_create_state(self, user_id: str) -> CollaborationState:
         """Get or create collaboration state for user"""
@@ -233,8 +245,7 @@ class EmpathyLLM:
         return self.states[user_id]
 
     def _determine_level(self, state: CollaborationState) -> int:
-        """
-        Determine which empathy level to use.
+        """Determine which empathy level to use.
 
         Progresses automatically based on state, up to target_level.
         """
@@ -251,8 +262,7 @@ class EmpathyLLM:
         return level
 
     def _build_system_prompt(self, level: int) -> str:
-        """
-        Build system prompt including Claude memory (if enabled).
+        """Build system prompt including Claude memory (if enabled).
 
         Claude memory is prepended to the level-specific prompt,
         so instructions from CLAUDE.md files affect all interactions.
@@ -262,6 +272,7 @@ class EmpathyLLM:
 
         Returns:
             Complete system prompt
+
         """
         level_prompt = EmpathyLevel.get_system_prompt(level)
 
@@ -273,14 +284,12 @@ class EmpathyLLM:
 # Empathy Framework Instructions
 {level_prompt}
 
-Follow the instructions from CLAUDE.md files above, then apply the Empathy Framework guidelines below.
+Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
 """
-        else:
-            return level_prompt
+        return level_prompt
 
     def reload_memory(self):
-        """
-        Reload Claude memory files.
+        """Reload Claude memory files.
 
         Useful if CLAUDE.md files have been updated during runtime.
         Call this to pick up changes without restarting.
@@ -301,8 +310,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
         force_level: int | None = None,
         task_type: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Main interaction method.
+        """Main interaction method.
 
         Automatically selects appropriate empathy level and responds.
 
@@ -336,6 +344,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
 
         Raises:
             SecurityError: If secrets detected and block_on_secrets=True
+
         """
         start_time = time.time()
         state = self._get_or_create_state(user_id)
@@ -358,7 +367,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
                 "routed_tier": tier.value,
             }
             logger.info(
-                f"Model routing: task={effective_task} -> model={routed_model} (tier={tier.value})"
+                f"Model routing: task={effective_task} -> model={routed_model} (tier={tier.value})",
             )
 
         # Initialize security tracking
@@ -374,7 +383,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
             security_metadata["pii_scrubbed"] = len(pii_detections) > 0
             if pii_detections:
                 logger.info(
-                    f"PII detected for user {user_id}: {len(pii_detections)} items scrubbed"
+                    f"PII detected for user {user_id}: {len(pii_detections)} items scrubbed",
                 )
 
         # Phase 3: Security Pipeline (Step 2 - Secrets Detection)
@@ -386,7 +395,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
                 block_on_secrets = self.security_config.get("block_on_secrets", True)
                 logger.warning(
                     f"Secrets detected for user {user_id}: {len(secrets_detections)} secrets, "
-                    f"blocking={block_on_secrets}"
+                    f"blocking={block_on_secrets}",
                 )
 
                 # Log security violation
@@ -406,7 +415,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
                 if block_on_secrets:
                     raise SecurityError(
                         f"Request blocked: {len(secrets_detections)} secret(s) detected in input. "
-                        f"Please remove sensitive credentials before submitting."
+                        f"Please remove sensitive credentials before submitting.",
                     )
 
         # Determine level to use
@@ -486,8 +495,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
         context: dict[str, Any],
         model_override: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Level 1: Reactive - Simple Q&A
+        """Level 1: Reactive - Simple Q&A
 
         No memory, no patterns, just respond to question.
         """
@@ -515,8 +523,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
         context: dict[str, Any],
         model_override: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Level 2: Guided - Ask clarifying questions
+        """Level 2: Guided - Ask clarifying questions
 
         Uses conversation history for context.
         """
@@ -552,8 +559,7 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
         context: dict[str, Any],
         model_override: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Level 3: Proactive - Act on detected patterns
+        """Level 3: Proactive - Act on detected patterns
 
         Checks for matching patterns and acts proactively.
         """
@@ -565,9 +571,9 @@ Follow the instructions from CLAUDE.md files above, then apply the Empathy Frame
             prompt = f"""
 User said: "{user_input}"
 
-I've detected a pattern: When you {matching_pattern.trigger}, you typically {matching_pattern.action}.
+Pattern detected: When you {matching_pattern.trigger}, you typically {matching_pattern.action}.
 
-Based on this pattern (confidence: {matching_pattern.confidence:.0%}), I'm proactively {matching_pattern.action}.
+Confidence: {matching_pattern.confidence:.0%}. Proactively {matching_pattern.action}.
 
 [Provide the expected result/action]
 
@@ -589,8 +595,8 @@ Was this helpful? If not, I can adjust my pattern detection.
             proactive = False
             pattern_info = None
 
-            # TODO: Run pattern detection in background
-            # await self._detect_patterns_async(state)
+            # Run pattern detection in background (non-blocking)
+            asyncio.create_task(self._detect_patterns_async(state, user_input))
 
         generate_kwargs: dict[str, Any] = {
             "messages": messages,
@@ -620,8 +626,7 @@ Was this helpful? If not, I can adjust my pattern detection.
         context: dict[str, Any],
         model_override: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Level 4: Anticipatory - Predict future needs
+        """Level 4: Anticipatory - Predict future needs
 
         Analyzes trajectory and alerts to future bottlenecks.
         """
@@ -633,7 +638,7 @@ COLLABORATION CONTEXT:
 - Total interactions: {len(state.interactions)}
 - Trust level: {state.trust_level:.2f}
 - Detected patterns: {len(state.detected_patterns)}
-- Success rate: {state.successful_actions / (state.successful_actions + state.failed_actions) if (state.successful_actions + state.failed_actions) > 0 else 0:.0%}
+- Success rate: {state.success_rate:.0%}
 
 TASK:
 1. Respond to immediate request
@@ -681,8 +686,7 @@ Use anticipatory format:
         context: dict[str, Any],
         model_override: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Level 5: Systems - Cross-domain pattern learning
+        """Level 5: Systems - Cross-domain pattern learning
 
         Leverages shared pattern library across domains.
         """
@@ -728,14 +732,125 @@ TASK:
             },
         }
 
-    def update_trust(self, user_id: str, outcome: str, magnitude: float = 1.0):
+    async def _detect_patterns_async(
+        self,
+        state: CollaborationState,
+        current_input: str,
+    ) -> None:
+        """Detect user behavior patterns in background.
+
+        Analyzes conversation history to identify:
+        - Sequential patterns: User always does X then Y
+        - Preference patterns: User prefers certain formats/styles
+        - Temporal patterns: User does X at specific times
+        - Conditional patterns: When Z happens, user does X
+
+        This runs asynchronously to avoid blocking the main response.
+        Detected patterns enable Level 3 proactive interactions.
         """
-        Update trust level based on interaction outcome.
+        try:
+            from datetime import datetime
+
+            interactions = state.interactions
+            if len(interactions) < 3:
+                # Need at least 3 interactions to detect patterns
+                return
+
+            # Analyze recent interactions for sequential patterns
+            recent = interactions[-10:]  # Last 10 interactions
+            user_messages = [i for i in recent if i.role == "user"]
+
+            if len(user_messages) < 2:
+                return
+
+            # Pattern 1: Sequential patterns (X followed by Y)
+            for i in range(len(user_messages) - 1):
+                current = user_messages[i].content.lower()
+                next_msg = user_messages[i + 1].content.lower()
+
+                # Detect common sequential patterns
+                sequential_triggers = [
+                    ("review", "fix"),  # Review then fix
+                    ("debug", "test"),  # Debug then test
+                    ("implement", "test"),  # Implement then test
+                    ("refactor", "review"),  # Refactor then review
+                ]
+
+                for trigger, action in sequential_triggers:
+                    if trigger in current and action in next_msg:
+                        pattern = UserPattern(
+                            pattern_type=PatternType.SEQUENTIAL,
+                            trigger=trigger,
+                            action=f"Typically follows with {action}",
+                            confidence=0.6 + (0.1 * min(i, 3)),  # Increase with occurrences
+                            occurrences=1,
+                            last_seen=datetime.now(),
+                            context={"detected_from": "sequential_analysis"},
+                        )
+                        state.add_pattern(pattern)
+
+            # Pattern 2: Preference patterns
+            preference_indicators = {
+                "concise": "brief, concise responses",
+                "detailed": "comprehensive, detailed responses",
+                "example": "responses with examples",
+                "step by step": "step-by-step explanations",
+                "code": "code-focused responses",
+            }
+
+            for indicator, preference in preference_indicators.items():
+                occurrences = sum(1 for m in user_messages if indicator in m.content.lower())
+                if occurrences >= 2:
+                    pattern = UserPattern(
+                        pattern_type=PatternType.PREFERENCE,
+                        trigger=indicator,
+                        action=f"User prefers {preference}",
+                        confidence=min(0.9, 0.5 + (0.1 * occurrences)),
+                        occurrences=occurrences,
+                        last_seen=datetime.now(),
+                        context={"preference_type": indicator},
+                    )
+                    state.add_pattern(pattern)
+
+            # Pattern 3: Conditional patterns (error -> debug)
+            conditional_triggers = [
+                ("error", "debug", "When errors occur, user asks for debugging"),
+                ("failed", "fix", "When tests fail, user asks for fixes"),
+                ("slow", "optimize", "When performance issues arise, user asks for optimization"),
+            ]
+
+            for condition, response_keyword, description in conditional_triggers:
+                for i, msg in enumerate(user_messages[:-1]):
+                    if condition in msg.content.lower():
+                        next_msg = user_messages[i + 1].content.lower()
+                        if response_keyword in next_msg:
+                            pattern = UserPattern(
+                                pattern_type=PatternType.CONDITIONAL,
+                                trigger=condition,
+                                action=description,
+                                confidence=0.7,
+                                occurrences=1,
+                                last_seen=datetime.now(),
+                                context={"condition": condition, "response": response_keyword},
+                            )
+                            state.add_pattern(pattern)
+
+            logger.debug(
+                f"Pattern detection complete. Detected {len(state.detected_patterns)} patterns.",
+            )
+
+        except Exception as e:
+            # Pattern detection should never break the main flow
+            logger.warning(f"Pattern detection error (non-critical): {e}")
+
+    def update_trust(self, user_id: str, outcome: str, magnitude: float = 1.0):
+        """Update trust level based on interaction outcome.
 
         Args:
             user_id: User identifier
             outcome: "success" or "failure"
             magnitude: How much to adjust (0.0 to 1.0)
+
         """
         state = self._get_or_create_state(user_id)
         state.update_trust(outcome, magnitude)
@@ -743,12 +858,12 @@ TASK:
         logger.info(f"Trust updated for {user_id}: {outcome} -> {state.trust_level:.2f}")
 
     def add_pattern(self, user_id: str, pattern: UserPattern):
-        """
-        Manually add a detected pattern.
+        """Manually add a detected pattern.
 
         Args:
             user_id: User identifier
             pattern: UserPattern instance
+
         """
         state = self._get_or_create_state(user_id)
         state.add_pattern(pattern)
@@ -756,14 +871,14 @@ TASK:
         logger.info(f"Pattern added for {user_id}: {pattern.pattern_type.value}")
 
     def get_statistics(self, user_id: str) -> dict[str, Any]:
-        """
-        Get collaboration statistics for user.
+        """Get collaboration statistics for user.
 
         Args:
             user_id: User identifier
 
         Returns:
             Dictionary with stats
+
         """
         state = self._get_or_create_state(user_id)
         return state.get_statistics()

empathy_llm_toolkit/git_pattern_extractor.py

@@ -1,5 +1,4 @@
-"""
-Git Pattern Extractor
+"""Git Pattern Extractor
 
 Automatically detects bug fixes from git commits and creates
 draft pattern entries for review.
@@ -32,8 +31,7 @@ logger = logging.getLogger(__name__)
 
 
 class GitPatternExtractor:
-    """
-    Extracts bug fix patterns from git commits.
+    """Extracts bug fix patterns from git commits.
 
     Analyzes commit messages and diffs to detect common
     fix patterns, then creates draft pattern files.
@@ -104,14 +102,14 @@ class GitPatternExtractor:
         }
 
     def extract_from_recent_commits(self, num_commits: int = 1) -> list[dict[str, Any]]:
-        """
-        Extract patterns from recent git commits.
+        """Extract patterns from recent git commits.
 
         Args:
             num_commits: Number of recent commits to analyze
 
         Returns:
             List of detected pattern dicts
+
         """
         patterns = []
 
@@ -138,11 +136,11 @@ class GitPatternExtractor:
         return patterns
 
     def extract_from_staged(self) -> list[dict[str, Any]]:
-        """
-        Extract patterns from currently staged changes.
+        """Extract patterns from currently staged changes.
 
         Returns:
             List of detected pattern dicts
+
         """
         diff = self._get_staged_diff()
         if not diff:
@@ -158,14 +156,14 @@ class GitPatternExtractor:
         return self._analyze_diff(diff, commit_info)
 
     def save_pattern(self, pattern: dict[str, Any]) -> Path | None:
-        """
-        Save a detected pattern as a draft for review.
+        """Save a detected pattern as a draft for review.
 
         Args:
             pattern: Pattern dict from extraction
 
         Returns:
             Path to saved file, or None if failed
+
         """
         self.debugging_dir.mkdir(parents=True, exist_ok=True)
 
@@ -175,7 +173,7 @@ class GitPatternExtractor:
             "date": datetime.now().isoformat(),
             "file_path": pattern.get("file", "unknown"),
             "error_type": pattern.get("type", "unknown"),
-            "error_message": f"Auto-detected from commit: {pattern.get('commit_message', '')[:100]}",
+            "error_message": f"From commit: {pattern.get('commit_message', '')[:80]}",
             "root_cause": "",  # To be filled by user
             "fix_applied": pattern.get("description", ""),
             "fix_code": pattern.get("code_sample", ""),
@@ -201,6 +199,7 @@ class GitPatternExtractor:
         try:
             result = subprocess.run(
                 ["git", "log", "-1", "--format=%H%n%s%n%an%n%aI", ref],
+                check=False,
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -226,6 +225,7 @@ class GitPatternExtractor:
         try:
             result = subprocess.run(
                 ["git", "diff", ref1, ref2],
+                check=False,
                 capture_output=True,
                 text=True,
                 timeout=10,
@@ -239,6 +239,7 @@ class GitPatternExtractor:
         try:
             result = subprocess.run(
                 ["git", "diff", "--cached"],
+                check=False,
                 capture_output=True,
                 text=True,
                 timeout=10,
@@ -252,6 +253,7 @@ class GitPatternExtractor:
         try:
             result = subprocess.run(
                 ["git", "config", key],
+                check=False,
                 capture_output=True,
                 text=True,
                 timeout=5,
@@ -286,7 +288,9 @@ class GitPatternExtractor:
                 # Process previous file
                 if current_file and added_lines:
                     file_patterns = self._detect_fix_patterns(
-                        current_file, added_lines, commit_info
+                        current_file,
+                        added_lines,
+                        commit_info,
                     )
                     patterns.extend(file_patterns)
 
@@ -334,7 +338,7 @@ class GitPatternExtractor:
                         "matches_count": len(matches),
                         "author": commit_info.get("author", "unknown"),
                         "date": commit_info.get("date", datetime.now().isoformat()),
-                    }
+                    },
                 )
 
         return detected

empathy_llm_toolkit/levels.py

@@ -1,5 +1,4 @@
-"""
-Empathy Level Definitions
+"""Empathy Level Definitions
 
 Defines behavior for each of the 5 empathy levels.
 
@@ -11,8 +10,7 @@ from enum import IntEnum
 
 
 class EmpathyLevel(IntEnum):
-    """
-    The 5 levels of AI-human collaboration empathy.
+    """The 5 levels of AI-human collaboration empathy.
 
     Each level builds on previous levels.
     """
@@ -38,7 +36,6 @@ class EmpathyLevel(IntEnum):
     @classmethod
     def get_system_prompt(cls, level: int) -> str:
         """Get system prompt for operating at specific level"""
-
         base = """You are an AI assistant using the Empathy Framework for collaboration.
 
 Your responses should be:
@@ -117,8 +114,7 @@ Pattern contribution:
 
     @classmethod
     def get_temperature_recommendation(cls, level: int) -> float:
-        """
-        Get recommended temperature for each level.
+        """Get recommended temperature for each level.
 
         Higher levels benefit from lower temperature (more focused).
         """
@@ -133,8 +129,7 @@ Pattern contribution:
 
     @classmethod
     def get_required_context(cls, level: int) -> dict[str, bool]:
-        """
-        Get context requirements for each level.
+        """Get context requirements for each level.
 
         Returns dict of {context_type: required}
         """
@@ -175,8 +170,7 @@ Pattern contribution:
 
     @classmethod
     def get_max_tokens_recommendation(cls, level: int) -> int:
-        """
-        Get recommended max_tokens for each level.
+        """Get recommended max_tokens for each level.
 
         Higher levels often need longer responses.
         """
@@ -190,8 +184,7 @@ Pattern contribution:
 
     @classmethod
     def should_use_json_mode(cls, level: int) -> bool:
-        """
-        Determine if JSON mode is beneficial for level.
+        """Determine if JSON mode is beneficial for level.
 
         Levels 4-5 benefit from structured output.
         """