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

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.
@@ -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()
@@ -157,7 +155,7 @@ class PatternSummaryGenerator:
                 "- **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",
+]