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

empathy_os/telemetry/cli.py

@@ -18,6 +18,7 @@ try:
     from rich.panel import Panel
     from rich.table import Table
     from rich.text import Text
+
     RICH_AVAILABLE = True
 except ImportError:
     RICH_AVAILABLE = False
@@ -149,7 +150,9 @@ def cmd_telemetry_show(args: Any) -> int:
         console.print(f"\n[dim]Data location: {tracker.telemetry_dir}[/dim]")
     else:
         # Fallback to plain text
-        print(f"\n{'Time':<19} {'Workflow':<20} {'Stage':<15} {'Tier':<10} {'Cost':>10} {'Cache':<10} {'Duration':>10}")
+        print(
+            f"\n{'Time':<19} {'Workflow':<20} {'Stage':<15} {'Tier':<10} {'Cost':>10} {'Cache':<10} {'Duration':>10}"
+        )
         print("-" * 120)
         total_cost = 0.0
         for entry in entries:
@@ -162,7 +165,9 @@ def cmd_telemetry_show(args: Any) -> int:
             duration_ms = entry.get("duration_ms", 0)
 
             cache_str = "HIT" if cache.get("hit") else "MISS"
-            print(f"{ts:<19} {workflow:<20} {stage:<15} {tier:<10} ${cost:>9.4f} {cache_str:<10} {duration_ms:>9}ms")
+            print(
+                f"{ts:<19} {workflow:<20} {stage:<15} {tier:<10} ${cost:>9.4f} {cache_str:<10} {duration_ms:>9}ms"
+            )
             total_cost += cost
 
         print("-" * 120)
@@ -209,7 +214,9 @@ def cmd_telemetry_savings(args: Any) -> int:
         content_lines.append(f"  Actual (tier routing):  ${savings['actual_cost']:.2f}")
         content_lines.append("")
         savings_color = "green" if savings["savings"] > 0 else "red"
-        content_lines.append(f"[bold {savings_color}]YOUR SAVINGS: ${savings['savings']:.2f} ({savings['savings_percent']:.1f}%)[/bold {savings_color}]")
+        content_lines.append(
+            f"[bold {savings_color}]YOUR SAVINGS: ${savings['savings']:.2f} ({savings['savings_percent']:.1f}%)[/bold {savings_color}]"
+        )
         content_lines.append("")
         content_lines.append(f"Cache savings: ${savings['cache_savings']:.2f}")
         content_lines.append(f"Total calls: {savings['total_calls']}")
@@ -271,7 +278,11 @@ def cmd_telemetry_compare(args: Any) -> int:
         table.add_column("Change", justify="right", style="blue")
 
         # Total calls
-        calls_change = ((stats1["total_calls"] - stats2["total_calls"]) / stats2["total_calls"] * 100) if stats2["total_calls"] > 0 else 0
+        calls_change = (
+            ((stats1["total_calls"] - stats2["total_calls"]) / stats2["total_calls"] * 100)
+            if stats2["total_calls"] > 0
+            else 0
+        )
         table.add_row(
             "Total Calls",
             str(stats1["total_calls"]),
@@ -280,7 +291,11 @@ def cmd_telemetry_compare(args: Any) -> int:
         )
 
         # Total cost
-        cost_change = ((stats1["total_cost"] - stats2["total_cost"]) / stats2["total_cost"] * 100) if stats2["total_cost"] > 0 else 0
+        cost_change = (
+            ((stats1["total_cost"] - stats2["total_cost"]) / stats2["total_cost"] * 100)
+            if stats2["total_cost"] > 0
+            else 0
+        )
         table.add_row(
             "Total Cost",
             f"${stats1['total_cost']:.2f}",
@@ -314,14 +329,28 @@ def cmd_telemetry_compare(args: Any) -> int:
         print("\n" + "=" * 80)
         print("TELEMETRY COMPARISON")
         print("=" * 80)
-        print(f"{'Metric':<20} {'Last ' + str(period1_days) + ' days':>20} {'Last ' + str(period2_days) + ' days':>20} {'Change':>15}")
+        print(
+            f"{'Metric':<20} {'Last ' + str(period1_days) + ' days':>20} {'Last ' + str(period2_days) + ' days':>20} {'Change':>15}"
+        )
         print("-" * 80)
 
-        calls_change = ((stats1["total_calls"] - stats2["total_calls"]) / stats2["total_calls"] * 100) if stats2["total_calls"] > 0 else 0
-        print(f"{'Total Calls':<20} {stats1['total_calls']:>20} {stats2['total_calls']:>20} {calls_change:>14.1f}%")
+        calls_change = (
+            ((stats1["total_calls"] - stats2["total_calls"]) / stats2["total_calls"] * 100)
+            if stats2["total_calls"] > 0
+            else 0
+        )
+        print(
+            f"{'Total Calls':<20} {stats1['total_calls']:>20} {stats2['total_calls']:>20} {calls_change:>14.1f}%"
+        )
 
-        cost_change = ((stats1["total_cost"] - stats2["total_cost"]) / stats2["total_cost"] * 100) if stats2["total_cost"] > 0 else 0
-        print(f"{'Total Cost':<20} ${stats1['total_cost']:>19.2f} ${stats2['total_cost']:>19.2f} {cost_change:>14.1f}%")
+        cost_change = (
+            ((stats1["total_cost"] - stats2["total_cost"]) / stats2["total_cost"] * 100)
+            if stats2["total_cost"] > 0
+            else 0
+        )
+        print(
+            f"{'Total Cost':<20} ${stats1['total_cost']:>19.2f} ${stats2['total_cost']:>19.2f} {cost_change:>14.1f}%"
+        )
 
         avg1 = stats1["total_cost"] / stats1["total_calls"] if stats1["total_calls"] > 0 else 0
         avg2 = stats2["total_cost"] / stats2["total_calls"] if stats2["total_calls"] > 0 else 0
@@ -329,7 +358,9 @@ def cmd_telemetry_compare(args: Any) -> int:
         print(f"{'Avg Cost/Call':<20} ${avg1:>19.4f} ${avg2:>19.4f} {avg_change:>14.1f}%")
 
         cache_change = stats1["cache_hit_rate"] - stats2["cache_hit_rate"]
-        print(f"{'Cache Hit Rate':<20} {stats1['cache_hit_rate']:>19.1f}% {stats2['cache_hit_rate']:>19.1f}% {cache_change:>14.1f}pp")
+        print(
+            f"{'Cache Hit Rate':<20} {stats1['cache_hit_rate']:>19.1f}% {stats2['cache_hit_rate']:>19.1f}% {cache_change:>14.1f}pp"
+        )
 
         print("=" * 80)
 
@@ -398,8 +429,20 @@ def cmd_telemetry_export(args: Any) -> int:
             return 0
 
         # Get all possible fields
-        fieldnames = ["ts", "workflow", "stage", "tier", "model", "provider", "cost",
-                     "tokens_input", "tokens_output", "cache_hit", "cache_type", "duration_ms"]
+        fieldnames = [
+            "ts",
+            "workflow",
+            "stage",
+            "tier",
+            "model",
+            "provider",
+            "cost",
+            "tokens_input",
+            "tokens_output",
+            "cache_hit",
+            "cache_type",
+            "duration_ms",
+        ]
 
         if output_file:
             validated_path = _validate_file_path(output_file)

empathy_os/telemetry/usage_tracker.py

@@ -356,9 +356,7 @@ class UsageTracker:
             by_provider[provider] = by_provider.get(provider, 0.0) + cost
 
         total_calls = len(entries)
-        cache_hit_rate = (
-            (cache_hits / total_calls * 100) if total_calls > 0 else 0.0
-        )
+        cache_hit_rate = (cache_hits / total_calls * 100) if total_calls > 0 else 0.0
 
         return {
             "total_calls": total_calls,
@@ -419,8 +417,7 @@ class UsageTracker:
 
         total_calls = len(entries)
         tier_distribution = {
-            tier: round(count / total_calls * 100, 1)
-            for tier, count in tier_counts.items()
+            tier: round(count / total_calls * 100, 1) for tier, count in tier_counts.items()
         }
 
         # Cache savings estimation

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

@@ -18,16 +18,16 @@ Usage:
     print(f"Expected cost: ${tier.expected_cost}")
 """
 
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional, Dict, Tuple
 import json
 from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
 
 
 @dataclass
 class TierRecommendationResult:
     """Result of tier recommendation."""
+
     tier: str  # CHEAP, CAPABLE, or PREMIUM
     confidence: float  # 0.0-1.0
     reasoning: str
@@ -49,11 +49,7 @@ class TierRecommender:
     - Cost optimization
     """
 
-    def __init__(
-        self,
-        patterns_dir: Optional[Path] = None,
-        confidence_threshold: float = 0.7
-    ):
+    def __init__(self, patterns_dir: Path | None = None, confidence_threshold: float = 0.7):
         """
         Initialize tier recommender.
 
@@ -67,7 +63,9 @@ class TierRecommender:
         """
         # Pattern 4: Range validation
         if not 0.0 <= confidence_threshold <= 1.0:
-            raise ValueError(f"confidence_threshold must be between 0.0 and 1.0, got {confidence_threshold}")
+            raise ValueError(
+                f"confidence_threshold must be between 0.0 and 1.0, got {confidence_threshold}"
+            )
 
         if patterns_dir is None:
             patterns_dir = Path(__file__).parent.parent.parent / "patterns" / "debugging"
@@ -79,9 +77,9 @@ class TierRecommender:
         # Build indexes for fast lookup
         self._build_indexes()
 
-    def _load_patterns(self) -> List[Dict]:
+    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
@@ -106,8 +104,8 @@ class TierRecommender:
 
     def _build_indexes(self):
         """Build indexes for fast pattern lookup."""
-        self.bug_type_index: Dict[str, List[Dict]] = defaultdict(list)
-        self.file_pattern_index: Dict[str, List[Dict]] = defaultdict(list)
+        self.bug_type_index: dict[str, list[dict]] = defaultdict(list)
+        self.file_pattern_index: dict[str, list[dict]] = defaultdict(list)
 
         for pattern in self.patterns:
             # Index by bug type
@@ -125,8 +123,8 @@ class TierRecommender:
     def recommend(
         self,
         bug_description: str,
-        files_affected: Optional[List[str]] = None,
-        complexity_hint: Optional[int] = None
+        files_affected: list[str] | None = None,
+        complexity_hint: int | None = None,
     ) -> TierRecommendationResult:
         """
         Recommend optimal starting tier for a new bug.
@@ -160,15 +158,13 @@ class TierRecommender:
 
         # Step 2: Find similar patterns
         similar_patterns = self._find_similar_patterns(
-            bug_type=bug_type,
-            files_affected=files_affected or []
+            bug_type=bug_type, files_affected=files_affected or []
         )
 
         # Step 3: If no similar patterns, use fallback logic
         if not similar_patterns:
             return self._fallback_recommendation(
-                bug_description=bug_description,
-                complexity_hint=complexity_hint
+                bug_description=bug_description, complexity_hint=complexity_hint
             )
 
         # Step 4: Analyze tier distribution in similar patterns
@@ -187,12 +183,12 @@ class TierRecommender:
                 bug_type=bug_type,
                 tier=recommended_tier,
                 confidence=confidence,
-                similar_count=len(similar_patterns)
+                similar_count=len(similar_patterns),
             ),
             expected_cost=cost_estimate["avg_cost"],
             expected_attempts=cost_estimate["avg_attempts"],
             similar_patterns_count=len(similar_patterns),
-            fallback_used=False
+            fallback_used=False,
         )
 
     def _classify_bug_type(self, description: str) -> str:
@@ -215,11 +211,7 @@ class TierRecommender:
 
         return "unknown"
 
-    def _find_similar_patterns(
-        self,
-        bug_type: str,
-        files_affected: List[str]
-    ) -> List[Dict]:
+    def _find_similar_patterns(self, bug_type: str, files_affected: list[str]) -> list[dict]:
         """Find patterns similar to current bug.
 
         Raises:
@@ -247,16 +239,11 @@ class TierRecommender:
 
         return similar
 
-    def _analyze_tier_distribution(
-        self,
-        patterns: List[Dict]
-    ) -> Dict[str, Dict]:
+    def _analyze_tier_distribution(self, patterns: list[dict]) -> dict[str, dict]:
         """Analyze tier success rates from similar patterns."""
-        tier_stats: Dict[str, Dict] = defaultdict(lambda: {
-            "count": 0,
-            "total_cost": 0.0,
-            "total_attempts": 0
-        })
+        tier_stats: dict[str, dict] = defaultdict(
+            lambda: {"count": 0, "total_cost": 0.0, "total_attempts": 0}
+        )
 
         for pattern in patterns:
             tp = pattern["tier_progression"]
@@ -268,7 +255,7 @@ class TierRecommender:
             stats["total_attempts"] += tp["total_attempts"]
 
         # Calculate averages
-        for tier, stats in tier_stats.items():
+        for _tier, stats in tier_stats.items():
             count = stats["count"]
             stats["success_rate"] = count / len(patterns)
             stats["avg_cost"] = stats["total_cost"] / count
@@ -276,19 +263,14 @@ class TierRecommender:
 
         return dict(tier_stats)
 
-    def _select_tier(
-        self,
-        tier_analysis: Dict[str, Dict]
-    ) -> Tuple[str, float]:
+    def _select_tier(self, tier_analysis: dict[str, dict]) -> tuple[str, float]:
         """Select best tier based on success rate and cost."""
         if not tier_analysis:
             return "CHEAP", 0.5
 
         # Sort by success rate
         sorted_tiers = sorted(
-            tier_analysis.items(),
-            key=lambda x: x[1]["success_rate"],
-            reverse=True
+            tier_analysis.items(), key=lambda x: x[1]["success_rate"], reverse=True
         )
 
         best_tier, stats = sorted_tiers[0]
@@ -296,16 +278,9 @@ class TierRecommender:
 
         return best_tier, confidence
 
-    def _estimate_cost(
-        self,
-        patterns: List[Dict],
-        tier: str
-    ) -> Dict[str, float]:
+    def _estimate_cost(self, patterns: list[dict], tier: str) -> dict[str, float]:
         """Estimate cost and attempts for recommended tier."""
-        matching = [
-            p for p in patterns
-            if p["tier_progression"]["successful_tier"] == tier
-        ]
+        matching = [p for p in patterns if p["tier_progression"]["successful_tier"] == tier]
 
         if not matching:
             # Default estimates by tier
@@ -316,24 +291,16 @@ class TierRecommender:
             }
             return defaults.get(tier, defaults["CHEAP"])
 
-        total_cost = sum(
-            p["tier_progression"]["cost_breakdown"]["total_cost"]
-            for p in matching
-        )
-        total_attempts = sum(
-            p["tier_progression"]["total_attempts"]
-            for p in matching
-        )
+        total_cost = sum(p["tier_progression"]["cost_breakdown"]["total_cost"] for p in matching)
+        total_attempts = sum(p["tier_progression"]["total_attempts"] for p in matching)
 
         return {
             "avg_cost": total_cost / len(matching),
-            "avg_attempts": total_attempts / len(matching)
+            "avg_attempts": total_attempts / len(matching),
         }
 
     def _fallback_recommendation(
-        self,
-        bug_description: str,
-        complexity_hint: Optional[int]
+        self, bug_description: str, complexity_hint: int | None
     ) -> TierRecommendationResult:
         """Provide fallback recommendation when no historical data available."""
 
@@ -356,7 +323,7 @@ class TierRecommender:
                 expected_cost=cost,
                 expected_attempts=2.0,
                 similar_patterns_count=0,
-                fallback_used=True
+                fallback_used=True,
             )
 
         # Default: start with CHEAP tier (conservative)
@@ -367,15 +334,11 @@ class TierRecommender:
             expected_cost=0.030,
             expected_attempts=1.5,
             similar_patterns_count=0,
-            fallback_used=True
+            fallback_used=True,
         )
 
     def _generate_reasoning(
-        self,
-        bug_type: str,
-        tier: str,
-        confidence: float,
-        similar_count: int
+        self, bug_type: str, tier: str, confidence: float, similar_count: int
     ) -> str:
         """Generate human-readable reasoning for recommendation."""
         percent = int(confidence * 100)
@@ -390,17 +353,14 @@ class TierRecommender:
                 f"resolved at {tier} tier"
             )
 
-    def get_stats(self) -> Dict:
+    def get_stats(self) -> dict:
         """Get overall statistics about pattern learning."""
         if not self.patterns:
-            return {
-                "total_patterns": 0,
-                "message": "No patterns loaded"
-            }
+            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:
@@ -418,5 +378,5 @@ class TierRecommender:
                 "CHEAP": tier_dist.get("CHEAP", 0),
                 "CAPABLE": tier_dist.get("CAPABLE", 0),
                 "PREMIUM": tier_dist.get("PREMIUM", 0),
-            }
+            },
         }

empathy_os/trust/__init__.py

@@ -8,13 +8,13 @@ Transfer: Protect user trust like protecting system stability
 """
 
 from .circuit_breaker import (
-                              TrustCircuitBreaker,
-                              TrustConfig,
-                              TrustDamageEvent,
-                              TrustDamageType,
-                              TrustRecoveryEvent,
-                              TrustState,
-                              create_trust_breaker,
+    TrustCircuitBreaker,
+    TrustConfig,
+    TrustDamageEvent,
+    TrustDamageType,
+    TrustRecoveryEvent,
+    TrustState,
+    create_trust_breaker,
 )
 
 __all__ = [

empathy_os/validation/__init__.py

@@ -7,9 +7,9 @@ Licensed under Fair Source License 0.9
 """
 
 from empathy_os.validation.xml_validator import (
-                                                 ValidationResult,
-                                                 XMLValidator,
-                                                 validate_xml_response,
+    ValidationResult,
+    XMLValidator,
+    validate_xml_response,
 )
 
 __all__ = [

empathy_os/workflow_patterns/output.py

@@ -33,7 +33,7 @@ class ResultDataclassPattern(WorkflowPattern):
 
     def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
         """Generate code for result dataclass."""
-        workflow_name = context.get("workflow_name", "my-workflow")
+        context.get("workflow_name", "my-workflow")
         class_name = context.get("class_name", "MyWorkflow")
         result_class_name = f"{class_name}Result"
 

empathy_os/workflow_patterns/structural.py

@@ -34,7 +34,7 @@ class SingleStagePattern(WorkflowPattern):
     def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
         """Generate code for single-stage workflow."""
         workflow_name = context.get("workflow_name", "MyWorkflow")
-        class_name = context.get("class_name", "MyWorkflow")
+        context.get("class_name", "MyWorkflow")
         description = context.get("description", "Single-stage workflow")
         tier = context.get("tier", "CAPABLE")
 
@@ -118,7 +118,7 @@ class MultiStagePattern(WorkflowPattern):
     def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
         """Generate code for multi-stage workflow."""
         workflow_name = context.get("workflow_name", "my-workflow")
-        class_name = context.get("class_name", "MyWorkflow")
+        context.get("class_name", "MyWorkflow")
         description = context.get("description", "Multi-stage workflow")
         stages = context.get("stages", ["analyze", "process", "report"])
         tier_map = context.get(
@@ -138,7 +138,7 @@ class MultiStagePattern(WorkflowPattern):
 
         # Generate stage routing
         stage_routing = []
-        for i, stage in enumerate(stages):
+        for _i, stage in enumerate(stages):
             stage_routing.append(
                 f"""        if stage_name == "{stage}":
             return await self._{stage}(input_data, tier)"""
@@ -229,7 +229,7 @@ class CrewBasedPattern(WorkflowPattern):
     def generate_code_sections(self, context: dict[str, Any]) -> list[CodeSection]:
         """Generate code for crew-based workflow."""
         workflow_name = context.get("workflow_name", "my-crew-workflow")
-        class_name = context.get("class_name", "MyCrewWorkflow")
+        context.get("class_name", "MyCrewWorkflow")
         description = context.get("description", "Crew-based workflow")
         crew_name = context.get("crew_name", "MyCrew")
 

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

@@ -605,11 +605,7 @@ def format_code_review_pipeline_report(result: CodeReviewPipelineResult) -> str:
     quality_label = (
         "EXCELLENT"
         if score >= 90
-        else "GOOD"
-        if score >= 70
-        else "NEEDS WORK"
-        if score >= 50
-        else "POOR"
+        else "GOOD" if score >= 70 else "NEEDS WORK" if score >= 50 else "POOR"
     )
     lines.append("-" * 60)
     lines.append("QUALITY SCORE")

empathy_os/workflows/dependency_check.py

@@ -321,11 +321,7 @@ class DependencyCheckWorkflow(BaseWorkflow):
         risk_level = (
             "critical"
             if risk_score >= 75
-            else "high"
-            if risk_score >= 50
-            else "medium"
-            if risk_score >= 25
-            else "low"
+            else "high" if risk_score >= 50 else "medium" if risk_score >= 25 else "low"
         )
 
         # Build vulnerability summary for LLM

empathy_os/workflows/keyboard_shortcuts/__init__.py

@@ -12,11 +12,11 @@ Features:
 
 from .generators import CLIAliasGenerator, MarkdownDocGenerator, VSCodeKeybindingsGenerator
 from .parsers import (
-                         FeatureParser,
-                         LLMFeatureAnalyzer,
-                         PyProjectParser,
-                         VSCodeCommandParser,
-                         YAMLManifestParser,
+    FeatureParser,
+    LLMFeatureAnalyzer,
+    PyProjectParser,
+    VSCodeCommandParser,
+    YAMLManifestParser,
 )
 from .schema import Category, Feature, FeatureManifest, LayoutConfig, ShortcutAssignment
 from .workflow import KeyboardShortcutWorkflow