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

coach_wizards/database_wizard.py

@@ -1,5 +1,4 @@
-"""
-DatabaseWizard - Database optimization and schema analysis
+"""DatabaseWizard - Database optimization and schema analysis
 
 Level 4 Anticipatory Empathy for Database using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class DatabaseWizard(BaseCoachWizard):
-    """
-    Database optimization and schema analysis
+    """Database optimization and schema analysis
 
     Detects:
     - missing indexes
@@ -36,8 +34,7 @@ class DatabaseWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for database issues
+        """Analyze code for database issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class DatabaseWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict database issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict database issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class DatabaseWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a database issue
+        """Suggest how to fix a database issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/debugging_wizard.py

@@ -1,5 +1,4 @@
-"""
-DebuggingWizard - Error detection and debugging assistance
+"""DebuggingWizard - Error detection and debugging assistance
 
 Level 4 Anticipatory Empathy for Debugging using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class DebuggingWizard(BaseCoachWizard):
-    """
-    Error detection and debugging assistance
+    """Error detection and debugging assistance
 
     Detects:
     - potential null references
@@ -36,8 +34,7 @@ class DebuggingWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for debugging issues
+        """Analyze code for debugging issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class DebuggingWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict debugging issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict debugging issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class DebuggingWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a debugging issue
+        """Suggest how to fix a debugging issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/documentation_wizard.py

@@ -1,5 +1,4 @@
-"""
-DocumentationWizard - Documentation quality and completeness
+"""DocumentationWizard - Documentation quality and completeness
 
 Level 4 Anticipatory Empathy for Documentation using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class DocumentationWizard(BaseCoachWizard):
-    """
-    Documentation quality and completeness
+    """Documentation quality and completeness
 
     Detects:
     - missing docstrings
@@ -36,8 +34,7 @@ class DocumentationWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for documentation issues
+        """Analyze code for documentation issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class DocumentationWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict documentation issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict documentation issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class DocumentationWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a documentation issue
+        """Suggest how to fix a documentation issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/generate_wizards.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
-"""
-Generate all 16 Coach wizards from template.
+"""Generate all 16 Coach wizards from template.
 
 This script generates the 16 specialized Coach wizards.
 This is a development/build utility, excluded from coverage via .coveragerc.

coach_wizards/localization_wizard.py

@@ -1,5 +1,4 @@
-"""
-LocalizationWizard - Internationalization and localization
+"""LocalizationWizard - Internationalization and localization
 
 Level 4 Anticipatory Empathy for Localization using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class LocalizationWizard(BaseCoachWizard):
-    """
-    Internationalization and localization
+    """Internationalization and localization
 
     Detects:
     - hardcoded strings
@@ -36,8 +34,7 @@ class LocalizationWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for localization issues
+        """Analyze code for localization issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -45,22 +42,107 @@ class LocalizationWizard(BaseCoachWizard):
         - Custom rule engines
         - AI models (Claude, GPT-4)
         """
-        issues = []
+        issues: list[WizardIssue] = []
 
-        # Example heuristic detection
-        lines = code.split("\n")
-        for _i, _line in enumerate(lines, 1):
-            # Add detection logic based on localization
-            pass
+        # Use generator-based iteration to avoid large list copies
+        # splitlines() is more memory-efficient than split("\n")
+        for line_num, line in enumerate(code.splitlines(), 1):
+            # Detect hardcoded strings (basic heuristic)
+            issue = self._check_hardcoded_string(line, line_num, file_path, language)
+            if issue:
+                issues.append(issue)
 
         self.logger.info(f"{self.name} found {len(issues)} issues in {file_path}")
         return issues
 
+    def _check_hardcoded_string(
+        self,
+        line: str,
+        line_num: int,
+        file_path: str,
+        language: str,
+    ) -> WizardIssue | None:
+        """Check a single line for hardcoded user-facing strings."""
+        # Skip comments and imports
+        stripped = line.strip()
+        if not stripped or stripped.startswith(("#", "//", "/*", "*", "import", "from")):
+            return None
+
+        # Basic detection patterns by language
+        # In production, use language-specific AST parsing
+        patterns = {
+            "python": self._check_python_hardcoded,
+            "javascript": self._check_js_hardcoded,
+            "typescript": self._check_js_hardcoded,
+            "jsx": self._check_js_hardcoded,
+            "tsx": self._check_js_hardcoded,
+        }
+
+        checker = patterns.get(language)
+        if checker:
+            return checker(line, line_num, file_path)
+        return None
+
+    def _check_python_hardcoded(
+        self,
+        line: str,
+        line_num: int,
+        file_path: str,
+    ) -> WizardIssue | None:
+        """Check Python code for hardcoded UI strings."""
+        # Look for print() or raise with string literals
+        # Skip logging, docstrings, and comments
+        if "print(" in line or "raise " in line:
+            # Check for quoted strings that look like UI text
+            if '"' in line or "'" in line:
+                # Basic heuristic: strings > 10 chars that aren't paths/URLs
+                import re
+
+                strings = re.findall(r'["\']([^"\']{10,})["\']', line)
+                for s in strings:
+                    if not s.startswith(("/", "http", "\\", ".")):
+                        return WizardIssue(
+                            category="hardcoded_string",
+                            severity="warning",
+                            message=f"Potential hardcoded UI string: '{s[:30]}...'",
+                            file_path=file_path,
+                            line_number=line_num,
+                            code_snippet=line.strip(),
+                            fix_suggestion="Consider using i18n translation function",
+                            confidence=0.7,
+                        )
+        return None
+
+    def _check_js_hardcoded(self, line: str, line_num: int, file_path: str) -> WizardIssue | None:
+        """Check JavaScript/TypeScript for hardcoded UI strings."""
+        # Look for JSX text content or string assignments
+        import re
+
+        # Check for text in JSX elements: <div>Hello World</div>
+        jsx_text = re.search(r">([A-Z][^<]{5,})<", line)
+        if jsx_text:
+            text = jsx_text.group(1).strip()
+            if text and not text.startswith("{"):
+                return WizardIssue(
+                    category="hardcoded_string",
+                    severity="warning",
+                    message=f"Hardcoded JSX text: '{text[:30]}...'",
+                    file_path=file_path,
+                    line_number=line_num,
+                    code_snippet=line.strip(),
+                    fix_suggestion="Use i18n: {t('key')} instead of hardcoded text",
+                    confidence=0.8,
+                )
+        return None
+
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict localization issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict localization issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -69,23 +151,23 @@ class LocalizationWizard(BaseCoachWizard):
         - Team velocity
         - Industry trends
         """
-        predictions = []
+        predictions: list[WizardPrediction] = []
 
         # Example prediction logic
         # In production, use ML models trained on historical data
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a localization issue
+        """Suggest how to fix a localization issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/migration_wizard.py

@@ -1,5 +1,4 @@
-"""
-MigrationWizard - Code migration and upgrade assistance
+"""MigrationWizard - Code migration and upgrade assistance
 
 Level 4 Anticipatory Empathy for Migration using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class MigrationWizard(BaseCoachWizard):
-    """
-    Code migration and upgrade assistance
+    """Code migration and upgrade assistance
 
     Detects:
     - deprecated APIs
@@ -36,8 +34,7 @@ class MigrationWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for migration issues
+        """Analyze code for migration issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class MigrationWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict migration issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict migration issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class MigrationWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a migration issue
+        """Suggest how to fix a migration issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/monitoring_wizard.py

@@ -1,5 +1,4 @@
-"""
-MonitoringWizard - System monitoring and alerting
+"""MonitoringWizard - System monitoring and alerting
 
 Level 4 Anticipatory Empathy for Monitoring using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class MonitoringWizard(BaseCoachWizard):
-    """
-    System monitoring and alerting
+    """System monitoring and alerting
 
     Detects:
     - missing alerts
@@ -36,8 +34,7 @@ class MonitoringWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for monitoring issues
+        """Analyze code for monitoring issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class MonitoringWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict monitoring issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict monitoring issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class MonitoringWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a monitoring issue
+        """Suggest how to fix a monitoring issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/observability_wizard.py

@@ -1,5 +1,4 @@
-"""
-ObservabilityWizard - Logging, metrics, and tracing analysis
+"""ObservabilityWizard - Logging, metrics, and tracing analysis
 
 Level 4 Anticipatory Empathy for Observability using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class ObservabilityWizard(BaseCoachWizard):
-    """
-    Logging, metrics, and tracing analysis
+    """Logging, metrics, and tracing analysis
 
     Detects:
     - missing logs
@@ -36,8 +34,7 @@ class ObservabilityWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for observability issues
+        """Analyze code for observability issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class ObservabilityWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict observability issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict observability issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class ObservabilityWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a observability issue
+        """Suggest how to fix a observability issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"

coach_wizards/performance_wizard.py

@@ -1,5 +1,4 @@
-"""
-PerformanceWizard - Performance optimization and bottleneck detection
+"""PerformanceWizard - Performance optimization and bottleneck detection
 
 Level 4 Anticipatory Empathy for Performance using the Empathy Framework.
 
@@ -13,8 +12,7 @@ from .base_wizard import BaseCoachWizard, WizardIssue, WizardPrediction
 
 
 class PerformanceWizard(BaseCoachWizard):
-    """
-    Performance optimization and bottleneck detection
+    """Performance optimization and bottleneck detection
 
     Detects:
     - N+1 queries
@@ -36,8 +34,7 @@ class PerformanceWizard(BaseCoachWizard):
         )
 
     def analyze_code(self, code: str, file_path: str, language: str) -> list[WizardIssue]:
-        """
-        Analyze code for performance issues
+        """Analyze code for performance issues
 
         This is a reference implementation. In production, integrate with:
         - Static analysis tools
@@ -57,10 +54,13 @@ class PerformanceWizard(BaseCoachWizard):
         return issues
 
     def predict_future_issues(
-        self, code: str, file_path: str, project_context: dict[str, Any], timeline_days: int = 90
+        self,
+        code: str,
+        file_path: str,
+        project_context: dict[str, Any],
+        timeline_days: int = 90,
     ) -> list[WizardPrediction]:
-        """
-        Level 4 Anticipatory: Predict performance issues {timeline_days} days ahead
+        """Level 4 Anticipatory: Predict performance issues {timeline_days} days ahead
 
         Uses:
         - Historical patterns
@@ -76,16 +76,16 @@ class PerformanceWizard(BaseCoachWizard):
 
         self.logger.info(
             f"{self.name} predicted {len(predictions)} future issues "
-            f"for {file_path} ({timeline_days} days ahead)"
+            f"for {file_path} ({timeline_days} days ahead)",
         )
         return predictions
 
     def suggest_fixes(self, issue: WizardIssue) -> str:
-        """
-        Suggest how to fix a performance issue
+        """Suggest how to fix a performance issue
 
         Returns:
             Detailed fix suggestion with code examples
+
         """
         # Implementation depends on issue type
         return f"Fix suggestion for {issue.category} issue: {issue.message}"