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

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

empathy_llm_toolkit/pattern_summary.py

@@ -1,5 +1,4 @@
-"""
-Pattern Summary Generator
+"""Pattern Summary Generator
 
 Generates a markdown summary of stored patterns for inclusion in CLAUDE.md.
 This enables Claude Code sessions to have context about historical patterns.
@@ -12,7 +11,7 @@ Usage:
     generator.write_to_file("./.claude/patterns_summary.md")
 
 CLI:
-    python -m empathy_llm_toolkit.pattern_summary --patterns-dir ./patterns --output ./.claude/patterns_summary.md
+    python -m empathy_llm_toolkit.pattern_summary --patterns-dir ./patterns --output patterns.md
 
 Author: Empathy Framework Team
 Version: 2.1.2
@@ -29,8 +28,7 @@ logger = logging.getLogger(__name__)
 
 
 class PatternSummaryGenerator:
-    """
-    Generates markdown summaries of stored patterns.
+    """Generates markdown summaries of stored patterns.
 
     Scans the patterns directory and produces a concise summary
     suitable for inclusion in CLAUDE.md via @import.
@@ -119,11 +117,11 @@ class PatternSummaryGenerator:
         return snapshots
 
     def generate_markdown(self) -> str:
-        """
-        Generate a markdown summary of all patterns.
+        """Generate a markdown summary of all patterns.
 
         Returns:
             Markdown string suitable for CLAUDE.md inclusion
+
         """
         if not any([self._bug_patterns, self._security_decisions, self._tech_debt_history]):
             self.load_all_patterns()
@@ -153,11 +151,11 @@ class PatternSummaryGenerator:
                 "",
                 "## How to Use These Patterns",
                 "",
-                "- **Debugging**: When encountering errors, check if similar bugs have been resolved",
-                "- **Security**: Before flagging security issues, check team decisions for false positives",
+                "- **Debugging**: Check if similar bugs have been resolved",
+                "- **Security**: Check team decisions for false positives",
                 "- **Tech Debt**: Consider debt trajectory when planning refactoring work",
                 "",
-            ]
+            ],
         )
 
         return "\n".join(lines)
@@ -247,7 +245,9 @@ class PatternSummaryGenerator:
 
         # Sort by date
         sorted_snapshots = sorted(
-            self._tech_debt_history, key=lambda s: s.get("date", ""), reverse=True
+            self._tech_debt_history,
+            key=lambda s: s.get("date", ""),
+            reverse=True,
         )
 
         # Current state (most recent)
@@ -295,11 +295,11 @@ class PatternSummaryGenerator:
         return lines
 
     def write_to_file(self, output_path: str) -> None:
-        """
-        Write the markdown summary to a file.
+        """Write the markdown summary to a file.
 
         Args:
             output_path: Path to write the summary
+
         """
         output = Path(output_path)
         output.parent.mkdir(parents=True, exist_ok=True)
@@ -326,7 +326,9 @@ def main():
         help="Output file path (default: ./.claude/patterns_summary.md)",
     )
     parser.add_argument(
-        "--print", action="store_true", help="Print to stdout instead of writing to file"
+        "--print",
+        action="store_true",
+        help="Print to stdout instead of writing to file",
     )
 
     args = parser.parse_args()

empathy_llm_toolkit/providers.py

@@ -1,5 +1,4 @@
-"""
-LLM Provider Adapters
+"""LLM Provider Adapters
 
 Unified interface for different LLM providers (OpenAI, Anthropic, local models).
 
@@ -24,8 +23,7 @@ class LLMResponse:
 
 
 class BaseLLMProvider(ABC):
-    """
-    Base class for all LLM providers.
+    """Base class for all LLM providers.
 
     Provides unified interface regardless of backend.
     """
@@ -43,8 +41,7 @@ class BaseLLMProvider(ABC):
         max_tokens: int = 1024,
         **kwargs,
     ) -> LLMResponse:
-        """
-        Generate response from LLM.
+        """Generate response from LLM.
 
         Args:
             messages: List of {"role": "user/assistant", "content": "..."}
@@ -55,17 +52,15 @@ class BaseLLMProvider(ABC):
 
         Returns:
             LLMResponse with standardized format
+
         """
-        pass
 
     @abstractmethod
     def get_model_info(self) -> dict[str, Any]:
         """Get information about the model being used"""
-        pass
 
     def estimate_tokens(self, text: str) -> int:
-        """
-        Estimate token count for text.
+        """Estimate token count for text.
 
         Rough approximation: ~4 chars per token
         """
@@ -73,8 +68,7 @@ class BaseLLMProvider(ABC):
 
 
 class AnthropicProvider(BaseLLMProvider):
-    """
-    Anthropic (Claude) provider with enhanced features.
+    """Anthropic (Claude) provider with enhanced features.
 
     Supports Claude 3 family models with advanced capabilities:
     - Extended context windows (200K tokens)
@@ -100,7 +94,7 @@ class AnthropicProvider(BaseLLMProvider):
         if not api_key or not api_key.strip():
             raise ValueError(
                 "API key is required for Anthropic provider. "
-                "Provide via api_key parameter or ANTHROPIC_API_KEY environment variable"
+                "Provide via api_key parameter or ANTHROPIC_API_KEY environment variable",
             )
 
         # Lazy import to avoid requiring anthropic if not used
@@ -110,7 +104,7 @@ class AnthropicProvider(BaseLLMProvider):
             self.client = anthropic.Anthropic(api_key=api_key)
         except ImportError as e:
             raise ImportError(
-                "anthropic package required. Install with: pip install anthropic"
+                "anthropic package required. Install with: pip install anthropic",
             ) from e
 
     async def generate(
@@ -121,15 +115,13 @@ class AnthropicProvider(BaseLLMProvider):
         max_tokens: int = 1024,
         **kwargs,
     ) -> LLMResponse:
-        """
-        Generate response using Anthropic API with enhanced features.
+        """Generate response using Anthropic API with enhanced features.
 
         Claude-specific enhancements:
         - Prompt caching for repeated system prompts (90% cost reduction)
         - Extended context (200K tokens) for large codebase analysis
         - Thinking mode for complex reasoning tasks
         """
-
         # Build kwargs for Anthropic
         api_kwargs = {
             "model": self.model,
@@ -145,7 +137,7 @@ class AnthropicProvider(BaseLLMProvider):
                     "type": "text",
                     "text": system_prompt,
                     "cache_control": {"type": "ephemeral"},  # Cache for 5 minutes
-                }
+                },
             ]
         elif system_prompt:
             api_kwargs["system"] = system_prompt
@@ -202,10 +194,12 @@ class AnthropicProvider(BaseLLMProvider):
         )
 
     async def analyze_large_codebase(
-        self, codebase_files: list[dict[str, str]], analysis_prompt: str, **kwargs
+        self,
+        codebase_files: list[dict[str, str]],
+        analysis_prompt: str,
+        **kwargs,
     ) -> LLMResponse:
-        """
-        Analyze large codebases using Claude's 200K context window.
+        """Analyze large codebases using Claude's 200K context window.
 
         Claude-specific feature: Can process entire repositories in one call.
 
@@ -216,10 +210,11 @@ class AnthropicProvider(BaseLLMProvider):
 
         Returns:
             LLMResponse with analysis results
+
         """
         # Build context from all files
         file_context = "\n\n".join(
-            [f"# File: {file['path']}\n{file['content']}" for file in codebase_files]
+            [f"# File: {file['path']}\n{file['content']}" for file in codebase_files],
         )
 
         # Create system prompt with caching for file context
@@ -287,8 +282,7 @@ class AnthropicProvider(BaseLLMProvider):
 
 
 class OpenAIProvider(BaseLLMProvider):
-    """
-    OpenAI provider.
+    """OpenAI provider.
 
     Supports GPT-4, GPT-3.5, and other OpenAI models.
     """
@@ -301,7 +295,7 @@ class OpenAIProvider(BaseLLMProvider):
         if not api_key or not api_key.strip():
             raise ValueError(
                 "API key is required for OpenAI provider. "
-                "Provide via api_key parameter or OPENAI_API_KEY environment variable"
+                "Provide via api_key parameter or OPENAI_API_KEY environment variable",
             )
 
         # Lazy import
@@ -321,7 +315,6 @@ class OpenAIProvider(BaseLLMProvider):
         **kwargs,
     ) -> LLMResponse:
         """Generate response using OpenAI API"""
-
         # Add system prompt if provided
         if system_prompt:
             messages = [{"role": "system", "content": system_prompt}] + messages
@@ -372,9 +365,182 @@ class OpenAIProvider(BaseLLMProvider):
         )
 
 
-class LocalProvider(BaseLLMProvider):
+class GeminiProvider(BaseLLMProvider):
+    """Google Gemini provider with cost tracking integration.
+
+    Supports Gemini models:
+    - gemini-2.0-flash-exp: Fast, cheap tier (1M context)
+    - gemini-1.5-pro: Balanced, capable tier (2M context)
+    - gemini-2.5-pro: Premium reasoning tier
     """
-    Local model provider (Ollama, LM Studio, etc.).
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        model: str = "gemini-1.5-pro",
+        **kwargs,
+    ):
+        super().__init__(api_key, **kwargs)
+        self.model = model
+
+        # Validate API key is provided
+        if not api_key or not api_key.strip():
+            raise ValueError(
+                "API key is required for Gemini provider. "
+                "Provide via api_key parameter or GOOGLE_API_KEY environment variable",
+            )
+
+        # Lazy import to avoid requiring google-generativeai if not used
+        try:
+            import google.generativeai as genai
+
+            genai.configure(api_key=api_key)
+            self.genai = genai
+            self.client = genai.GenerativeModel(model)
+        except ImportError as e:
+            raise ImportError(
+                "google-generativeai package required. Install with: pip install google-generativeai",
+            ) from e
+
+    async def generate(
+        self,
+        messages: list[dict[str, str]],
+        system_prompt: str | None = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+        **kwargs,
+    ) -> LLMResponse:
+        """Generate response using Google Gemini API.
+
+        Gemini-specific features:
+        - Large context windows (1M-2M tokens)
+        - Multimodal support
+        - Grounding with Google Search
+        """
+        import asyncio
+
+        # Convert messages to Gemini format
+        gemini_messages = []
+        for msg in messages:
+            role = "user" if msg["role"] == "user" else "model"
+            gemini_messages.append({"role": role, "parts": [msg["content"]]})
+
+        # Build generation config
+        generation_config = self.genai.GenerationConfig(
+            temperature=temperature,
+            max_output_tokens=max_tokens,
+        )
+
+        # Create model with system instruction if provided
+        if system_prompt:
+            model = self.genai.GenerativeModel(
+                self.model,
+                system_instruction=system_prompt,
+            )
+        else:
+            model = self.client
+
+        # Call Gemini API (run sync in thread pool for async compatibility)
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(
+            None,
+            lambda: model.generate_content(
+                gemini_messages,  # type: ignore[arg-type]
+                generation_config=generation_config,
+            ),
+        )
+
+        # Extract token counts from usage metadata
+        input_tokens = 0
+        output_tokens = 0
+        if hasattr(response, "usage_metadata"):
+            input_tokens = getattr(response.usage_metadata, "prompt_token_count", 0)
+            output_tokens = getattr(response.usage_metadata, "candidates_token_count", 0)
+
+        # Log to cost tracker
+        try:
+            from empathy_os.cost_tracker import log_request
+
+            tier = self._get_tier()
+            log_request(
+                model=self.model,
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                task_type=kwargs.get("task_type", "gemini_generate"),
+                tier=tier,
+            )
+        except ImportError:
+            pass  # Cost tracking not available
+
+        # Convert to standardized format
+        content = ""
+        if response.candidates:
+            content = response.candidates[0].content.parts[0].text
+
+        finish_reason = "stop"
+        if response.candidates and hasattr(response.candidates[0], "finish_reason"):
+            finish_reason = str(response.candidates[0].finish_reason.name).lower()
+
+        return LLMResponse(
+            content=content,
+            model=self.model,
+            tokens_used=input_tokens + output_tokens,
+            finish_reason=finish_reason,
+            metadata={
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "provider": "google",
+                "model_family": "gemini",
+            },
+        )
+
+    def _get_tier(self) -> str:
+        """Determine tier from model name."""
+        if "flash" in self.model.lower():
+            return "cheap"
+        if "2.5" in self.model or "ultra" in self.model.lower():
+            return "premium"
+        return "capable"
+
+    def get_model_info(self) -> dict[str, Any]:
+        """Get Gemini model information"""
+        model_info = {
+            "gemini-2.0-flash-exp": {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 0.075,
+                "cost_per_1m_output": 0.30,
+                "supports_vision": True,
+                "ideal_for": "Fast responses, simple tasks, large context",
+            },
+            "gemini-1.5-pro": {
+                "max_tokens": 2000000,
+                "cost_per_1m_input": 1.25,
+                "cost_per_1m_output": 5.00,
+                "supports_vision": True,
+                "ideal_for": "Complex reasoning, large codebases",
+            },
+            "gemini-2.5-pro": {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 2.50,
+                "cost_per_1m_output": 10.00,
+                "supports_vision": True,
+                "ideal_for": "Advanced reasoning, complex tasks",
+            },
+        }
+
+        return model_info.get(
+            self.model,
+            {
+                "max_tokens": 1000000,
+                "cost_per_1m_input": 1.25,
+                "cost_per_1m_output": 5.00,
+                "supports_vision": True,
+            },
+        )
+
+
+class LocalProvider(BaseLLMProvider):
+    """Local model provider (Ollama, LM Studio, etc.).
 
     For running models locally.
     """

empathy_llm_toolkit/routing/__init__.py

@@ -0,0 +1,32 @@
+"""Empathy Framework Model Routing
+
+Smart routing of tasks to appropriate model tiers for cost optimization:
+- CHEAP tier: Triage, summarization, classification (Haiku/GPT-4o-mini)
+- CAPABLE tier: Code generation, analysis, sub-agent work (Sonnet/GPT-4o)
+- PREMIUM tier: Coordination, synthesis, critical decisions (Opus/o1)
+
+Example:
+    >>> from empathy_llm_toolkit.routing import ModelRouter
+    >>>
+    >>> router = ModelRouter()
+    >>> model = router.route("summarize", provider="anthropic")
+    >>> print(model)  # claude-3-5-haiku-20241022
+    >>>
+    >>> model = router.route("coordinate", provider="anthropic")
+    >>> print(model)  # claude-opus-4-20250514
+    >>>
+    >>> cost = router.estimate_cost("fix_bug", input_tokens=5000, output_tokens=1000)
+    >>> print(f"Estimated cost: ${cost:.4f}")
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+
+"""
+
+from .model_router import ModelRouter, ModelTier, TaskRouting
+
+__all__ = [
+    "ModelRouter",
+    "ModelTier",
+    "TaskRouting",
+]