empathy-framework 3.9.1__py3-none-any.whl → 3.9.3__py3-none-any.whl

empathy_os/workflows/tier_tracking.py

@@ -12,10 +12,10 @@ Licensed under Fair Source License 0.9
 
 import json
 import uuid
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from empathy_os.logging_config import get_logger
 
@@ -29,8 +29,8 @@ class TierAttempt:
     tier: str
     attempt: int
     success: bool
-    quality_gate_failed: Optional[str] = None
-    quality_gates_passed: Optional[List[str]] = None
+    quality_gate_failed: str | None = None
+    quality_gates_passed: list[str] | None = None
 
 
 @dataclass
@@ -40,7 +40,7 @@ class WorkflowTierProgression:
     workflow_name: str
     workflow_id: str
     bug_description: str
-    files_affected: List[str]
+    files_affected: list[str]
     bug_type: str
 
     # Tier progression
@@ -48,7 +48,7 @@ class WorkflowTierProgression:
     starting_tier: str
     successful_tier: str
     total_attempts: int
-    tier_history: List[Dict[str, Any]]
+    tier_history: list[dict[str, Any]]
 
     # Costs
     total_cost: float
@@ -65,7 +65,7 @@ class WorkflowTierProgression:
     duration_seconds: float
 
     # Optional fields must come last
-    error_message: Optional[str] = None
+    error_message: str | None = None
 
 
 class WorkflowTierTracker:
@@ -89,7 +89,7 @@ class WorkflowTierTracker:
         self,
         workflow_name: str,
         workflow_description: str,
-        patterns_dir: Optional[Path] = None,
+        patterns_dir: Path | None = None,
     ):
         """
         Initialize tier tracker for a workflow.
@@ -109,13 +109,13 @@ class WorkflowTierTracker:
         self.patterns_dir = Path(patterns_dir)
         self.patterns_dir.mkdir(parents=True, exist_ok=True)
 
-        self.recommended_tier: Optional[str] = None
-        self.starting_tier: Optional[str] = None
-        self.tier_attempts: List[TierAttempt] = []
+        self.recommended_tier: str | None = None
+        self.starting_tier: str | None = None
+        self.tier_attempts: list[TierAttempt] = []
 
     def show_recommendation(
         self,
-        files_affected: Optional[List[str]] = None,
+        files_affected: list[str] | None = None,
         show_ui: bool = True,
     ) -> str:
         """
@@ -173,7 +173,9 @@ class WorkflowTierTracker:
         if result.fallback_used:
             message += "\n\n[yellow]⚠️  Using default - limited historical data[/yellow]"
         else:
-            message += f"\n\n[green]✅ Based on {result.similar_patterns_count} similar patterns[/green]"
+            message += (
+                f"\n\n[green]✅ Based on {result.similar_patterns_count} similar patterns[/green]"
+            )
 
         console.print(Panel(message, title="🎯 Auto Tier Recommendation", border_style="cyan"))
 
@@ -182,8 +184,8 @@ class WorkflowTierTracker:
         tier: str,
         attempt: int,
         success: bool,
-        quality_gate_failed: Optional[str] = None,
-        quality_gates_passed: Optional[List[str]] = None,
+        quality_gate_failed: str | None = None,
+        quality_gates_passed: list[str] | None = None,
     ):
         """Record a tier attempt during workflow execution."""
         self.tier_attempts.append(
@@ -199,9 +201,9 @@ class WorkflowTierTracker:
     def save_progression(
         self,
         workflow_result: Any,
-        files_affected: Optional[List[str]] = None,
+        files_affected: list[str] | None = None,
         bug_type: str = "workflow_run",
-    ) -> Optional[Path]:
+    ) -> Path | None:
         """
         Save tier progression data after workflow completion.
 
@@ -225,9 +227,17 @@ class WorkflowTierTracker:
             tier_history = self._build_tier_history(workflow_result)
 
             # Calculate costs
-            total_cost = workflow_result.cost_report.get("total", 0) if isinstance(workflow_result.cost_report, dict) else sum(stage.cost for stage in workflow_result.stages)
+            total_cost = (
+                workflow_result.cost_report.get("total", 0)
+                if isinstance(workflow_result.cost_report, dict)
+                else sum(stage.cost for stage in workflow_result.stages)
+            )
             cost_if_premium = self._estimate_premium_cost(workflow_result)
-            savings_percent = ((cost_if_premium - total_cost) / cost_if_premium * 100) if cost_if_premium > 0 else 0
+            savings_percent = (
+                ((cost_if_premium - total_cost) / cost_if_premium * 100)
+                if cost_if_premium > 0
+                else 0
+            )
 
             # Create progression record
             progression = {
@@ -240,7 +250,6 @@ class WorkflowTierTracker:
                 "resolved_at": completed_at.strftime("%Y-%m-%d"),
                 "files_affected": files_affected or [],
                 "source": "workflow_tracking",
-
                 "tier_progression": {
                     "methodology": "AI-ADDIE",
                     "recommended_tier": self.recommended_tier or self.starting_tier,
@@ -266,7 +275,6 @@ class WorkflowTierTracker:
                         "false_complete_avoided": workflow_result.error is None,
                     },
                 },
-
                 "workflow_metadata": {
                     "workflow_name": self.workflow_name,
                     "workflow_id": self.workflow_id,
@@ -298,8 +306,10 @@ class WorkflowTierTracker:
             return "CHEAP"
 
         # Use the highest tier that was actually used
-        tiers_used = [stage.tier.value if hasattr(stage.tier, 'value') else str(stage.tier).lower()
-                      for stage in workflow_result.stages]
+        tiers_used = [
+            stage.tier.value if hasattr(stage.tier, "value") else str(stage.tier).lower()
+            for stage in workflow_result.stages
+        ]
 
         if "premium" in tiers_used:
             return "PREMIUM"
@@ -308,13 +318,13 @@ class WorkflowTierTracker:
         else:
             return "CHEAP"
 
-    def _build_tier_history(self, workflow_result: Any) -> List[Dict[str, Any]]:
+    def _build_tier_history(self, workflow_result: Any) -> list[dict[str, Any]]:
         """Build tier history from workflow stages."""
-        tier_groups: Dict[str, List[Any]] = {}
+        tier_groups: dict[str, list[Any]] = {}
 
         # Group stages by tier
         for stage in workflow_result.stages:
-            tier = stage.tier.value if hasattr(stage.tier, 'value') else str(stage.tier).lower()
+            tier = stage.tier.value if hasattr(stage.tier, "value") else str(stage.tier).lower()
             tier_upper = tier.upper()
             if tier_upper not in tier_groups:
                 tier_groups[tier_upper] = []
@@ -328,7 +338,7 @@ class WorkflowTierTracker:
             success_stage = None
 
             for i, stage in enumerate(stages, 1):
-                if hasattr(stage, 'error') and stage.error:
+                if hasattr(stage, "error") and stage.error:
                     failures.append({"attempt": i, "quality_gate_failed": "execution"})
                 else:
                     success_stage = i
@@ -359,12 +369,12 @@ 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
 
-    def _update_consolidated_patterns(self, progression: Dict[str, Any]):
+    def _update_consolidated_patterns(self, progression: dict[str, Any]):
         """Update the consolidated patterns.json file."""
         consolidated_file = self.patterns_dir / "all_patterns.json"
 
@@ -391,7 +401,7 @@ class WorkflowTierTracker:
 def auto_recommend_tier(
     workflow_name: str,
     workflow_description: str,
-    files_affected: Optional[List[str]] = None,
+    files_affected: list[str] | None = None,
 ) -> str:
     """
     Quick helper to get tier recommendation without tracker.

empathy_software_plugin/cli.py

@@ -662,9 +662,7 @@ def scan_command():
                     severity_icon = (
                         "🔴"
                         if issue.severity == "high"
-                        else "🟡"
-                        if issue.severity == "medium"
-                        else "🔵"
+                        else "🟡" if issue.severity == "medium" else "🔵"
                     )
                     print(f"    {severity_icon} Line {issue.line_number}: {issue.message}")
                 if len(result.issues) > 3:

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/code_review_wizard.py

@@ -561,9 +561,7 @@ class CodeReviewWizard(BaseWizard):
             icon = (
                 "⚠️"
                 if finding["severity"] == "warning"
-                else "❌"
-                if finding["severity"] == "error"
-                else "ℹ️"
+                else "❌" if finding["severity"] == "error" else "ℹ️"
             )
             lines.append(f"{icon}  {finding['file']}:{finding['line']}")
             lines.append(f"    Pattern: {finding['pattern_type']} ({finding['pattern_id']})")

empathy_software_plugin/wizards/debugging/__init__.py

@@ -10,10 +10,10 @@ from .bug_risk_analyzer import BugRisk, BugRiskAnalyzer, RiskAssessment
 from .config_loaders import ConfigLoaderFactory, LintConfig, load_config
 from .fix_applier import FixApplierFactory, FixResult, apply_fixes, group_issues_by_fixability
 from .language_patterns import (
-                          CrossLanguagePatternLibrary,
-                          PatternCategory,
-                          UniversalPattern,
-                          get_pattern_library,
+    CrossLanguagePatternLibrary,
+    PatternCategory,
+    UniversalPattern,
+    get_pattern_library,
 )
 from .linter_parsers import LinterParserFactory, LintIssue, Severity, parse_linter_output
 from .verification import VerificationResult, compare_issue_lists, run_linter, verify_fixes

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/__init__.py

@@ -9,12 +9,12 @@ Licensed under Fair Source License 0.9
 from .exploit_analyzer import ExploitAnalyzer
 from .owasp_patterns import OWASPPatternDetector
 from .vulnerability_scanner import (
-                                    DependencyVulnerability,
-                                    Severity,
-                                    Vulnerability,
-                                    VulnerabilityScanner,
-                                    VulnerabilityScanReport,
-                                    VulnerabilityType,
+    DependencyVulnerability,
+    Severity,
+    Vulnerability,
+    VulnerabilityScanner,
+    VulnerabilityScanReport,
+    VulnerabilityType,
 )
 
 __all__ = [

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: [],

empathy_os/.empathy/costs.json

@@ -1,60 +0,0 @@
-{
-  "requests": [
-    {
-      "timestamp": "2026-01-07T06:30:40.722211",
-      "model": "claude-3-5-haiku-20241022",
-      "tier": "cheap",
-      "task_type": "workflow:refactor-plan:scan",
-      "input_tokens": 0,
-      "output_tokens": 572,
-      "actual_cost": 0.002288,
-      "baseline_cost": 0.0429,
-      "savings": 0.040612
-    },
-    {
-      "timestamp": "2026-01-07T06:30:40.723099",
-      "model": "claude-sonnet-4-20250514",
-      "tier": "capable",
-      "task_type": "workflow:refactor-plan:analyze",
-      "input_tokens": 676,
-      "output_tokens": 193,
-      "actual_cost": 0.004923,
-      "baseline_cost": 0.024615,
-      "savings": 0.019692
-    },
-    {
-      "timestamp": "2026-01-07T06:30:43.930646",
-      "model": "claude-sonnet-4-20250514",
-      "tier": "capable",
-      "task_type": "workflow:refactor-plan:prioritize",
-      "input_tokens": 873,
-      "output_tokens": 736,
-      "actual_cost": 0.013659,
-      "baseline_cost": 0.068295,
-      "savings": 0.054636
-    },
-    {
-      "timestamp": "2026-01-07T06:30:43.934470",
-      "model": "claude-opus-4-5-20251101",
-      "tier": "premium",
-      "task_type": "workflow:refactor-plan:plan",
-      "input_tokens": 0,
-      "output_tokens": 0,
-      "actual_cost": 0.0,
-      "baseline_cost": 0.0,
-      "savings": 0.0
-    }
-  ],
-  "daily_totals": {
-    "2026-01-07": {
-      "requests": 4,
-      "input_tokens": 1549,
-      "output_tokens": 1501,
-      "actual_cost": 0.02087,
-      "baseline_cost": 0.13581,
-      "savings": 0.11494
-    }
-  },
-  "created_at": "2026-01-07T06:30:37.244775",
-  "last_updated": "2026-01-07T06:30:43.934483"
-}

empathy_os/.empathy/discovery_stats.json

@@ -1,15 +0,0 @@
-{
-  "command_counts": {
-    "workflow": 1
-  },
-  "tips_shown": [
-    "weekly_sync"
-  ],
-  "total_commands": 1,
-  "patterns_learned": 0,
-  "api_requests": 0,
-  "tech_debt_trend": "unknown",
-  "last_claude_sync": null,
-  "first_run": "2026-01-07T06:30:43.936384",
-  "last_updated": "2026-01-07T06:30:43.936546"
-}

empathy_os/.empathy/workflow_runs.json

@@ -1,45 +0,0 @@
-[
-  {
-    "workflow": "refactor-plan",
-    "provider": "anthropic",
-    "success": true,
-    "started_at": "2026-01-07T06:30:40.702139",
-    "completed_at": "2026-01-07T06:30:43.934850",
-    "duration_ms": 3232,
-    "cost": 0.02087,
-    "baseline_cost": 0.13581,
-    "savings": 0.11493999999999999,
-    "savings_percent": 84.63294308224725,
-    "stages": [
-      {
-        "name": "scan",
-        "tier": "cheap",
-        "skipped": false,
-        "cost": 0.002288,
-        "duration_ms": 20
-      },
-      {
-        "name": "analyze",
-        "tier": "capable",
-        "skipped": false,
-        "cost": 0.004923,
-        "duration_ms": 0
-      },
-      {
-        "name": "prioritize",
-        "tier": "capable",
-        "skipped": false,
-        "cost": 0.013659,
-        "duration_ms": 3207
-      },
-      {
-        "name": "plan",
-        "tier": "premium",
-        "skipped": false,
-        "cost": 0.0,
-        "duration_ms": 3
-      }
-    ],
-    "error": null
-  }
-]