empathy-framework 3.5.6__py3-none-any.whl → 3.7.0__py3-none-any.whl

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

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
@@ -373,8 +366,7 @@ class OpenAIProvider(BaseLLMProvider):
 
 
 class GeminiProvider(BaseLLMProvider):
-    """
-    Google Gemini provider with cost tracking integration.
+    """Google Gemini provider with cost tracking integration.
 
     Supports Gemini models:
     - gemini-2.0-flash-exp: Fast, cheap tier (1M context)
@@ -395,7 +387,7 @@ class GeminiProvider(BaseLLMProvider):
         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"
+                "Provide via api_key parameter or GOOGLE_API_KEY environment variable",
             )
 
         # Lazy import to avoid requiring google-generativeai if not used
@@ -407,7 +399,7 @@ class GeminiProvider(BaseLLMProvider):
             self.client = genai.GenerativeModel(model)
         except ImportError as e:
             raise ImportError(
-                "google-generativeai package required. Install with: pip install google-generativeai"
+                "google-generativeai package required. Install with: pip install google-generativeai",
             ) from e
 
     async def generate(
@@ -418,8 +410,7 @@ class GeminiProvider(BaseLLMProvider):
         max_tokens: int = 1024,
         **kwargs,
     ) -> LLMResponse:
-        """
-        Generate response using Google Gemini API.
+        """Generate response using Google Gemini API.
 
         Gemini-specific features:
         - Large context windows (1M-2M tokens)
@@ -454,7 +445,7 @@ class GeminiProvider(BaseLLMProvider):
         response = await loop.run_in_executor(
             None,
             lambda: model.generate_content(
-                gemini_messages,
+                gemini_messages,  # type: ignore[arg-type]
                 generation_config=generation_config,
             ),
         )
@@ -507,10 +498,9 @@ class GeminiProvider(BaseLLMProvider):
         """Determine tier from model name."""
         if "flash" in self.model.lower():
             return "cheap"
-        elif "2.5" in self.model or "ultra" in self.model.lower():
+        if "2.5" in self.model or "ultra" in self.model.lower():
             return "premium"
-        else:
-            return "capable"
+        return "capable"
 
     def get_model_info(self) -> dict[str, Any]:
         """Get Gemini model information"""
@@ -550,8 +540,7 @@ class GeminiProvider(BaseLLMProvider):
 
 
 class LocalProvider(BaseLLMProvider):
-    """
-    Local model provider (Ollama, LM Studio, etc.).
+    """Local model provider (Ollama, LM Studio, etc.).
 
     For running models locally.
     """