empathy-framework 3.2.3__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.
 
@@ -23,7 +22,13 @@ 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, PatternType, UserPattern
 
@@ -31,8 +36,7 @@ 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.
@@ -86,6 +90,7 @@ class EmpathyLLM:
         ...     user_input="Design the architecture",
         ...     task_type="architectural_decision"
         ... )
+
     """
 
     def __init__(
@@ -102,8 +107,7 @@ class EmpathyLLM:
         enable_model_routing: bool = False,
         **kwargs,
     ):
-        """
-        Initialize EmpathyLLM.
+        """Initialize EmpathyLLM.
 
         Args:
             provider: "anthropic", "openai", or "local"
@@ -127,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 {}
@@ -158,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+)
@@ -174,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):
@@ -208,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"""
@@ -234,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.
         """
@@ -252,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.
@@ -263,6 +272,7 @@ class EmpathyLLM:
 
         Returns:
             Complete system prompt
+
         """
         level_prompt = EmpathyLevel.get_system_prompt(level)
 
@@ -276,12 +286,10 @@ class EmpathyLLM:
 
 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.
@@ -302,8 +310,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
         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.
 
@@ -337,6 +344,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
 
         Raises:
             SecurityError: If secrets detected and block_on_secrets=True
+
         """
         start_time = time.time()
         state = self._get_or_create_state(user_id)
@@ -359,7 +367,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
                 "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
@@ -375,7 +383,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
             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)
@@ -387,7 +395,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
                 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
@@ -407,7 +415,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
                 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
@@ -487,8 +495,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
         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.
         """
@@ -516,8 +523,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
         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.
         """
@@ -553,8 +559,7 @@ Follow the CLAUDE.md instructions above, then apply the Empathy Framework below.
         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.
         """
@@ -621,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.
         """
@@ -682,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.
         """
@@ -734,8 +737,7 @@ TASK:
         state: CollaborationState,
         current_input: str,
     ) -> None:
-        """
-        Detect user behavior patterns in background.
+        """Detect user behavior patterns in background.
 
         Analyzes conversation history to identify:
         - Sequential patterns: User always does X then Y
@@ -834,7 +836,7 @@ TASK:
                             state.add_pattern(pattern)
 
             logger.debug(
-                f"Pattern detection complete. Detected {len(state.detected_patterns)} patterns."
+                f"Pattern detection complete. Detected {len(state.detected_patterns)} patterns.",
             )
 
         except Exception as e:
@@ -842,13 +844,13 @@ TASK:
             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.
+        """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)
@@ -856,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)
@@ -869,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)
 
@@ -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.
         """

empathy_llm_toolkit/pattern_confidence.py

@@ -1,5 +1,4 @@
-"""
-Pattern Confidence Scoring
+"""Pattern Confidence Scoring
 
 Tracks how often stored fixes resolve similar issues,
 building confidence scores over time.
@@ -85,8 +84,7 @@ class PatternUsageStats:
 
 
 class PatternConfidenceTracker:
-    """
-    Tracks pattern usage and calculates confidence scores.
+    """Tracks pattern usage and calculates confidence scores.
 
     Stores usage data in patterns/confidence/usage_stats.json
     """
@@ -151,8 +149,7 @@ class PatternConfidenceTracker:
         return self._stats[pattern_id]
 
     def record_suggestion(self, pattern_id: str) -> None:
-        """
-        Record that a pattern was suggested to the user.
+        """Record that a pattern was suggested to the user.
 
         Call this when a pattern is shown as a potential fix.
         """
@@ -168,13 +165,13 @@ class PatternConfidenceTracker:
         successful: bool = True,
         notes: str | None = None,
     ) -> None:
-        """
-        Record that a pattern fix was applied.
+        """Record that a pattern fix was applied.
 
         Args:
             pattern_id: The pattern that was applied
             successful: Whether the fix resolved the issue
             notes: Optional feedback notes
+
         """
         stats = self._get_or_create_stats(pattern_id)
         stats.times_applied += 1
@@ -191,7 +188,7 @@ class PatternConfidenceTracker:
                     "date": datetime.now().isoformat(),
                     "successful": successful,
                     "notes": notes,
-                }
+                },
             )
 
         self._save()
@@ -203,11 +200,11 @@ class PatternConfidenceTracker:
         )
 
     def get_pattern_stats(self, pattern_id: str) -> dict[str, Any]:
-        """
-        Get usage statistics for a pattern.
+        """Get usage statistics for a pattern.
 
         Returns:
             Dict with usage stats and calculated scores
+
         """
         stats = self._get_or_create_stats(pattern_id)
         return {
@@ -230,14 +227,14 @@ class PatternConfidenceTracker:
         return [self.get_pattern_stats(pid) for pid in self._stats]
 
     def get_top_patterns(self, limit: int = 10) -> list[dict[str, Any]]:
-        """
-        Get top patterns by confidence score.
+        """Get top patterns by confidence score.
 
         Args:
             limit: Maximum patterns to return
 
         Returns:
             List of pattern stats, sorted by confidence
+
         """
         self._ensure_loaded()
         all_stats = self.get_all_stats()
@@ -249,14 +246,14 @@ class PatternConfidenceTracker:
         return sorted_stats[:limit]
 
     def get_stale_patterns(self, days: int = 90) -> list[dict[str, Any]]:
-        """
-        Get patterns that haven't been used recently.
+        """Get patterns that haven't been used recently.
 
         Args:
             days: Number of days to consider stale
 
         Returns:
             List of stale pattern stats
+
         """
         self._ensure_loaded()
         stale = []
@@ -275,8 +272,7 @@ class PatternConfidenceTracker:
         return stale
 
     def update_pattern_summary(self) -> bool:
-        """
-        Update the patterns_summary.md with confidence scores.
+        """Update the patterns_summary.md with confidence scores.
 
         This adds a confidence section to the generated summary.
         """
@@ -297,7 +293,7 @@ class PatternConfidenceTracker:
                 icon = "🟢" if score >= 0.8 else "🟡" if score >= 0.5 else "🔴"
                 confidence_section.append(
                     f"- {icon} **{p['pattern_id']}**: {score:.0%} confidence "
-                    f"({p['times_applied']} applied, {p['times_successful']} successful)"
+                    f"({p['times_applied']} applied, {p['times_successful']} successful)",
                 )
 
             confidence_section.append("")

empathy_llm_toolkit/pattern_resolver.py

@@ -1,5 +1,4 @@
-"""
-Pattern Resolution Module
+"""Pattern Resolution Module
 
 Provides CLI workflow for resolving investigating bug patterns
 by adding root cause, fix, and resolution time.
@@ -40,8 +39,7 @@ logger = logging.getLogger(__name__)
 
 
 class PatternResolver:
-    """
-    Resolves investigating bug patterns with root cause and fix information.
+    """Resolves investigating bug patterns with root cause and fix information.
 
     Searches through pattern directories to find matching bug IDs
     and updates them with resolution details.
@@ -52,14 +50,14 @@ class PatternResolver:
         self._debugging_dirs = ["debugging", "debugging_demo", "repo_test/debugging"]
 
     def find_bug(self, bug_id: str) -> tuple[Path | None, dict[str, Any] | None]:
-        """
-        Find a bug pattern by ID.
+        """Find a bug pattern by ID.
 
         Args:
             bug_id: The bug ID to find (e.g., "bug_20251212_3c5b9951")
 
         Returns:
             Tuple of (file_path, pattern_data) or (None, None) if not found
+
         """
         for debug_dir in self._debugging_dirs:
             dir_path = self.patterns_dir / debug_dir
@@ -88,11 +86,11 @@ class PatternResolver:
         return None, None
 
     def list_investigating(self) -> list[dict[str, Any]]:
-        """
-        List all bugs with status 'investigating'.
+        """List all bugs with status 'investigating'.
 
         Returns:
             List of bug patterns that need resolution
+
         """
         investigating = []
 
@@ -122,8 +120,7 @@ class PatternResolver:
         resolution_time_minutes: int = 0,
         resolved_by: str = "@developer",
     ) -> bool:
-        """
-        Resolve a bug pattern by updating its fields.
+        """Resolve a bug pattern by updating its fields.
 
         Args:
             bug_id: The bug ID to resolve
@@ -135,6 +132,7 @@ class PatternResolver:
 
         Returns:
             True if successfully resolved, False otherwise
+
         """
         file_path, pattern = self.find_bug(bug_id)
 
@@ -165,11 +163,11 @@ class PatternResolver:
             return False
 
     def regenerate_summary(self) -> bool:
-        """
-        Regenerate the patterns_summary.md file.
+        """Regenerate the patterns_summary.md file.
 
         Returns:
             True if successful, False otherwise
+
         """
         try:
             from empathy_llm_toolkit.pattern_summary import PatternSummaryGenerator