empathy-framework 3.9.2__py3-none-any.whl → 3.10.1__py3-none-any.whl

empathy_os/test_generator/generator.py

@@ -60,7 +60,7 @@ class TestGenerator:
         pattern_ids: list[str],
         wizard_module: str | None = None,
         wizard_class: str | None = None,
-    ) -> dict[str, str]:
+    ) -> dict[str, str | None]:
         """Generate tests for a wizard.
 
         Args:

empathy_os/tier_recommender.py

@@ -79,7 +79,7 @@ class TierRecommender:
 
     def _load_patterns(self) -> list[dict]:
         """Load all enhanced patterns with tier_progression data."""
-        patterns = []
+        patterns: list[dict] = []
 
         if not self.patterns_dir.exists():
             return patterns
@@ -359,8 +359,8 @@ class TierRecommender:
             return {"total_patterns": 0, "message": "No patterns loaded"}
 
         # Calculate tier distribution
-        tier_dist = defaultdict(int)
-        bug_type_dist = defaultdict(int)
+        tier_dist: dict[str, int] = defaultdict(int)
+        bug_type_dist: dict[str, int] = defaultdict(int)
         total_savings = 0.0
 
         for pattern in self.patterns:

empathy_os/workflows/base.py

@@ -26,6 +26,9 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+if TYPE_CHECKING:
+    from .tier_tracking import WorkflowTierTracker
+
 # Load .env file for API keys if python-dotenv is available
 try:
     from dotenv import load_dotenv
@@ -430,7 +433,7 @@ class BaseWorkflow(ABC):
 
         # Tier tracking support
         self._enable_tier_tracking = enable_tier_tracking
-        self._tier_tracker = None
+        self._tier_tracker: WorkflowTierTracker | None = None
 
         # Telemetry tracking (singleton instance)
         self._telemetry_tracker: UsageTracker | None = None
@@ -569,7 +572,7 @@ class BaseWorkflow(ABC):
                     logger.debug(f"Cache hit for {self.name}:{stage}")
                     # Determine cache type
                     if hasattr(self._cache, "cache_type"):
-                        ct = self._cache.cache_type  # type: ignore
+                        ct = self._cache.cache_type
                         # Ensure it's a string (not a Mock object)
                         cache_type = str(ct) if ct and isinstance(ct, str) else "hash"
                     else:

empathy_os/workflows/health_check.py

@@ -87,6 +87,7 @@ class HealthCheckWorkflow(BaseWorkflow):
         check_tests: bool = True,
         check_deps: bool = True,
         xml_prompts: bool = True,
+        health_score_threshold: int = 95,
         **kwargs: Any,
     ):
         """Initialize health check workflow.
@@ -98,6 +99,8 @@ class HealthCheckWorkflow(BaseWorkflow):
             check_tests: Run test checks
             check_deps: Run dependency checks
             xml_prompts: Use XML-enhanced prompts
+            health_score_threshold: Minimum health score required (0-100, default: 95)
+                                   100 = perfect health, 95 = very strict (default), 80 = moderate
             **kwargs: Additional arguments passed to BaseWorkflow
 
         """
@@ -108,6 +111,7 @@ class HealthCheckWorkflow(BaseWorkflow):
         self.check_tests = check_tests
         self.check_deps = check_deps
         self.xml_prompts = xml_prompts
+        self.health_score_threshold = health_score_threshold
         self._crew: Any = None
         self._crew_available = False
 
@@ -153,6 +157,39 @@ class HealthCheckWorkflow(BaseWorkflow):
             return await self._fix(input_data, tier)
         raise ValueError(f"Unknown stage: {stage_name}")
 
+    def validate_output(self, stage_output: dict) -> tuple[bool, str | None]:
+        """Validate health check output quality.
+
+        For health-check workflow, we validate that:
+        1. Diagnosis data is present
+        2. Health score meets the configured threshold (default: 95 = very strict quality)
+        3. No critical execution errors occurred
+
+        Args:
+            stage_output: Output from diagnose or fix stage
+
+        Returns:
+            Tuple of (is_valid, failure_reason)
+
+        """
+        # First run parent validation (checks for empty output, errors)
+        is_valid, reason = super().validate_output(stage_output)
+        if not is_valid:
+            return False, reason
+
+        # Check diagnosis data exists
+        diagnosis = stage_output.get("diagnosis", {})
+        if not diagnosis:
+            return False, "diagnosis_missing"
+
+        # Check health score meets configured threshold
+        health_score = diagnosis.get("health_score", 0)
+        if health_score < self.health_score_threshold:
+            return False, "health_score_low"
+
+        # All validation passed
+        return True, None
+
     async def _diagnose(self, input_data: dict, tier: ModelTier) -> tuple[dict, int, int]:
         """Run health diagnosis using HealthCheckCrew.
 

empathy_os/workflows/new_sample_workflow1.py

@@ -80,7 +80,7 @@ class NewSampleWorkflow1Workflow(BaseWorkflow):
 
         """
         # TODO: Implement analyze logic
-        prompt = f"{stage} stage: {input_data}"
+        prompt = f"analyze stage: {input_data}"
 
         if self.executor:
             result = await self.executor.execute(
@@ -107,7 +107,7 @@ class NewSampleWorkflow1Workflow(BaseWorkflow):
 
         """
         # TODO: Implement process logic
-        prompt = f"{stage} stage: {input_data}"
+        prompt = f"process stage: {input_data}"
 
         if self.executor:
             result = await self.executor.execute(
@@ -134,7 +134,7 @@ class NewSampleWorkflow1Workflow(BaseWorkflow):
 
         """
         # TODO: Implement report logic
-        prompt = f"{stage} stage: {input_data}"
+        prompt = f"report stage: {input_data}"
 
         if self.executor:
             result = await self.executor.execute(

empathy_os/workflows/tier_tracking.py

@@ -369,7 +369,7 @@ class WorkflowTierTracker:
         )
 
         # Calculate actual cost from stages
-        actual_cost = sum(stage.cost for stage in workflow_result.stages)
+        actual_cost: float = sum(stage.cost for stage in workflow_result.stages)
 
         # Rough estimate: PREMIUM tier is ~15x more expensive than CHEAP
         return actual_cost * 5  # Conservative multiplier

empathy_software_plugin/wizards/advanced_debugging_wizard.py

@@ -47,8 +47,8 @@ class AdvancedDebuggingWizard(BaseWizard):
         super().__init__()
         self.bug_analyzer = BugRiskAnalyzer()
         self.pattern_library = get_pattern_library()
-        self._name = "Advanced Debugging Wizard"
-        self._level = 4
+        self._name: str = "Advanced Debugging Wizard"
+        self._level: int = 4
 
     @property
     def name(self) -> str:
@@ -126,7 +126,8 @@ class AdvancedDebuggingWizard(BaseWizard):
         # Phase 4: Group by fixability
         fixability_by_linter = {}
         for linter_name, result in linter_results.items():
-            fixability = group_issues_by_fixability(linter_name, result["issues"])
+            issues_for_fixability: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+            fixability = group_issues_by_fixability(linter_name, issues_for_fixability)
             fixability_by_linter[linter_name] = {
                 "auto_fixable": len(fixability["auto_fixable"]),
                 "manual": len(fixability["manual"]),
@@ -138,7 +139,8 @@ class AdvancedDebuggingWizard(BaseWizard):
             logger.info("Applying auto-fixes...")
 
             for linter_name, result in linter_results.items():
-                fixes = apply_fixes(linter_name, result["issues"], dry_run=False, auto_only=True)
+                issues_for_fixing: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+                fixes = apply_fixes(linter_name, issues_for_fixing, dry_run=False, auto_only=True)
 
                 successful = [f for f in fixes if f.success]
                 failed = [f for f in fixes if not f.success]
@@ -155,7 +157,8 @@ class AdvancedDebuggingWizard(BaseWizard):
             logger.info("Verifying fixes...")
 
             for linter_name, result in linter_results.items():
-                verification = verify_fixes(linter_name, project_path, result["issues"])
+                issues_for_verification: list[LintIssue] = result["issues"]  # type: ignore[assignment]
+                verification = verify_fixes(linter_name, project_path, issues_for_verification)
 
                 verification_results[linter_name] = verification.to_dict()
 
@@ -201,7 +204,7 @@ class AdvancedDebuggingWizard(BaseWizard):
         insights = []
 
         # Group issues by language
-        by_language = {}
+        by_language: dict[str, list[LintIssue]] = {}
         for issue in issues:
             lang = issue.linter
             if lang not in by_language:

empathy_software_plugin/wizards/debugging/bug_risk_analyzer.py

@@ -335,7 +335,7 @@ class BugRiskAnalyzer:
         This is the Level 4 alert format.
         """
         # Count by risk level
-        by_risk = {
+        by_risk: dict[BugRisk, list[RiskAssessment]] = {
             BugRisk.CRITICAL: [],
             BugRisk.HIGH: [],
             BugRisk.MEDIUM: [],

empathy_software_plugin/wizards/debugging/config_loaders.py

@@ -246,15 +246,19 @@ class PylintConfigLoader(BaseConfigLoader):
         """Load from pyproject.toml"""
         try:
             import tomli
+
+            toml_loader = tomli
         except ImportError:
             # Fallback for Python 3.11+
             try:
-                import tomllib as tomli
+                import tomllib
+
+                toml_loader = tomllib
             except ImportError as e:
                 raise ImportError("tomli or tomllib required for pyproject.toml") from e
 
         with open(path, "rb") as f:
-            data = tomli.load(f)
+            data = toml_loader.load(f)
 
         pylint_config = data.get("tool", {}).get("pylint", {})
 

empathy_software_plugin/wizards/debugging/language_patterns.py

@@ -278,6 +278,7 @@ class CrossLanguagePatternLibrary:
             UniversalPattern if found, None otherwise
 
         """
+        pattern: UniversalPattern
         for pattern in self.patterns.values():
             if linter in pattern.language_manifestations:
                 if pattern.language_manifestations[linter] == rule:
@@ -295,11 +296,12 @@ class CrossLanguagePatternLibrary:
             List of fix steps, or None if not found
 
         """
-        pattern = self.patterns.get(pattern_name)
+        pattern: UniversalPattern | None = self.patterns.get(pattern_name)
         if not pattern:
             return None
 
-        return pattern.language_specific_fixes.get(language)
+        result: list[str] | None = pattern.language_specific_fixes.get(language)
+        return result
 
     def suggest_cross_language_insight(
         self,

empathy_software_plugin/wizards/debugging/linter_parsers.py

@@ -360,7 +360,7 @@ class ClippyParser(BaseLinterParser):
 
         # Pattern: warning: unused variable: `x`
         #   --> src/main.rs:5:9
-        current_issue = {}
+        current_issue: dict[str, Any] = {}
 
         for line in output.split("\n"):
             # Check for severity line

empathy_software_plugin/wizards/performance/profiler_parsers.py

@@ -167,20 +167,20 @@ class ChromeDevToolsParser(BaseProfilerParser):
                     function_times[name]["call_count"] += 1
 
             # Convert to FunctionProfile
-            total_time = sum(data["total_time"] for data in function_times.values())
+            total_time = sum(stats["total_time"] for stats in function_times.values())
 
-            for func_name, data in function_times.items():
+            for func_name, stats in function_times.items():
                 profiles.append(
                     FunctionProfile(
                         function_name=func_name,
                         file_path="",  # Chrome doesn't always provide
                         line_number=0,
-                        total_time=data["total_time"],
-                        self_time=data["total_time"],
-                        call_count=data["call_count"],
-                        cumulative_time=data["total_time"],
+                        total_time=stats["total_time"],
+                        self_time=stats["total_time"],
+                        call_count=stats["call_count"],
+                        cumulative_time=stats["total_time"],
                         percent_total=(
-                            (data["total_time"] / total_time * 100) if total_time > 0 else 0
+                            (stats["total_time"] / total_time * 100) if total_time > 0 else 0
                         ),
                         profiler=self.profiler_name,
                     ),

empathy_software_plugin/wizards/security/vulnerability_scanner.py

@@ -225,7 +225,7 @@ class VulnerabilityScanner:
         lines: list[str],
     ) -> list[Vulnerability]:
         """Scan for hardcoded secrets"""
-        vulnerabilities = []
+        vulnerabilities: list[Vulnerability] = []
 
         # Skip certain file types
         if file_path.suffix in [".md", ".txt", ".json", ".xml"]:

empathy_software_plugin/wizards/security_analysis_wizard.py

@@ -168,10 +168,10 @@ class SecurityAnalysisWizard(BaseWizard):
 
     def _group_by_category(self, vulnerabilities: list[dict[str, Any]]) -> dict[str, int]:
         """Group vulnerabilities by OWASP category"""
-        by_category = {}
+        by_category: dict[str, int] = {}
 
         for vuln in vulnerabilities:
-            category = vuln.get("category", "unknown")
+            category: str = str(vuln.get("category", "unknown"))
             by_category[category] = by_category.get(category, 0) + 1
 
         return by_category

empathy_software_plugin/wizards/testing/quality_analyzer.py

@@ -8,7 +8,7 @@ Licensed under Fair Source License 0.9
 """
 
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 from typing import Any
@@ -37,14 +37,8 @@ class TestFunction:
     assertions_count: int
     execution_time: float | None = None
     is_async: bool = False
-    uses_fixtures: list[str] | None = None
-    issues: list[TestQualityIssue] | None = None
-
-    def __post_init__(self):
-        if self.uses_fixtures is None:
-            self.uses_fixtures = []
-        if self.issues is None:
-            self.issues = []
+    uses_fixtures: list[str] = field(default_factory=list)
+    issues: list[TestQualityIssue] = field(default_factory=list)
 
     @property
     def quality_score(self) -> float:

empathy_software_plugin/wizards/testing/test_suggester.py

@@ -494,7 +494,7 @@ def {test_name}({params_str}):
         summary.append("=" * 60)
 
         # Group by priority
-        by_priority = {
+        by_priority: dict[TestPriority, list[TestSuggestion]] = {
             TestPriority.CRITICAL: [],
             TestPriority.HIGH: [],
             TestPriority.MEDIUM: [],