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

empathy_os/models/__init__.py

@@ -12,64 +12,64 @@ Licensed under Fair Source License 0.9
 from .empathy_executor import EmpathyLLMExecutor
 from .executor import ExecutionContext, LLMExecutor, LLMResponse, MockLLMExecutor
 from .fallback import (
-                       DEFAULT_FALLBACK_POLICY,
-                       DEFAULT_RETRY_POLICY,
-                       CircuitBreaker,
-                       CircuitBreakerState,
-                       FallbackPolicy,
-                       FallbackStep,
-                       FallbackStrategy,
-                       ResilientExecutor,
-                       RetryPolicy,
+    DEFAULT_FALLBACK_POLICY,
+    DEFAULT_RETRY_POLICY,
+    CircuitBreaker,
+    CircuitBreakerState,
+    FallbackPolicy,
+    FallbackStep,
+    FallbackStrategy,
+    ResilientExecutor,
+    RetryPolicy,
 )
 from .provider_config import (
-                       ProviderConfig,
-                       ProviderMode,
-                       configure_provider_cli,
-                       configure_provider_interactive,
-                       get_provider_config,
-                       reset_provider_config,
-                       set_provider_config,
+    ProviderConfig,
+    ProviderMode,
+    configure_provider_cli,
+    configure_provider_interactive,
+    get_provider_config,
+    reset_provider_config,
+    set_provider_config,
 )
 from .registry import (
-                       MODEL_REGISTRY,
-                       ModelInfo,
-                       ModelProvider,
-                       ModelTier,
-                       get_all_models,
-                       get_model,
-                       get_pricing_for_model,
+    MODEL_REGISTRY,
+    ModelInfo,
+    ModelProvider,
+    ModelTier,
+    get_all_models,
+    get_model,
+    get_pricing_for_model,
 )
 from .tasks import (
-                       CAPABLE_TASKS,
-                       CHEAP_TASKS,
-                       PREMIUM_TASKS,
-                       TASK_TIER_MAP,
-                       TaskInfo,
-                       TaskType,
-                       get_all_tasks,
-                       get_tasks_for_tier,
-                       get_tier_for_task,
-                       is_known_task,
-                       normalize_task_type,
+    CAPABLE_TASKS,
+    CHEAP_TASKS,
+    PREMIUM_TASKS,
+    TASK_TIER_MAP,
+    TaskInfo,
+    TaskType,
+    get_all_tasks,
+    get_tasks_for_tier,
+    get_tier_for_task,
+    is_known_task,
+    normalize_task_type,
 )
 from .telemetry import (
-                       LLMCallRecord,
-                       TelemetryAnalytics,
-                       TelemetryBackend,
-                       TelemetryStore,
-                       WorkflowRunRecord,
-                       WorkflowStageRecord,
-                       get_telemetry_store,
-                       log_llm_call,
-                       log_workflow_run,
+    LLMCallRecord,
+    TelemetryAnalytics,
+    TelemetryBackend,
+    TelemetryStore,
+    WorkflowRunRecord,
+    WorkflowStageRecord,
+    get_telemetry_store,
+    log_llm_call,
+    log_workflow_run,
 )
 from .validation import (
-                       ConfigValidator,
-                       ValidationError,
-                       ValidationResult,
-                       validate_config,
-                       validate_yaml_file,
+    ConfigValidator,
+    ValidationError,
+    ValidationResult,
+    validate_config,
+    validate_yaml_file,
 )
 
 __all__ = [

empathy_os/monitoring/__init__.py

@@ -25,13 +25,13 @@ from empathy_os.agent_monitoring import AgentMetrics, AgentMonitor, TeamMetrics
 
 # Import telemetry classes
 from empathy_os.models.telemetry import (
-                                         LLMCallRecord,
-                                         TelemetryAnalytics,
-                                         TelemetryStore,
-                                         WorkflowRunRecord,
-                                         get_telemetry_store,
-                                         log_llm_call,
-                                         log_workflow_run,
+    LLMCallRecord,
+    TelemetryAnalytics,
+    TelemetryStore,
+    WorkflowRunRecord,
+    get_telemetry_store,
+    log_llm_call,
+    log_workflow_run,
 )
 
 __all__ = [

empathy_os/optimization/__init__.py

@@ -7,9 +7,9 @@ Licensed under Fair Source License 0.9
 """
 
 from empathy_os.optimization.context_optimizer import (
-                                                       CompressionLevel,
-                                                       ContextOptimizer,
-                                                       optimize_xml_prompt,
+    CompressionLevel,
+    ContextOptimizer,
+    optimize_xml_prompt,
 )
 
 __all__ = [

empathy_os/pattern_library.py

@@ -262,9 +262,7 @@ class PatternLibrary:
         """
         pattern = self.patterns.get(pattern_id)
         if not pattern:
-            raise ValueError(
-                f"Pattern '{pattern_id}' not found. Cannot record outcome."
-            )
+            raise ValueError(f"Pattern '{pattern_id}' not found. Cannot record outcome.")
         pattern.record_usage(success)
 
     def link_patterns(self, pattern_id_1: str, pattern_id_2: str):
@@ -300,10 +298,7 @@ class PatternLibrary:
                 self.pattern_graph[pattern_id_2].append(pattern_id_1)
 
     def get_related_patterns(
-        self,
-        pattern_id: str,
-        depth: int = 1,
-        _visited: set[str] | None = None
+        self, pattern_id: str, depth: int = 1, _visited: set[str] | None = None
     ) -> list[Pattern]:
         """Get patterns related to a given pattern
 

empathy_os/plugins/__init__.py

@@ -7,12 +7,12 @@ Licensed under Fair Source 0.9
 """
 
 from .base import (
-                   BasePlugin,
-                   BaseWizard,
-                   PluginError,
-                   PluginLoadError,
-                   PluginMetadata,
-                   PluginValidationError,
+    BasePlugin,
+    BaseWizard,
+    PluginError,
+    PluginLoadError,
+    PluginMetadata,
+    PluginValidationError,
 )
 from .registry import PluginRegistry, get_global_registry
 

empathy_os/resilience/__init__.py

@@ -18,11 +18,11 @@ Licensed under Fair Source 0.9
 """
 
 from .circuit_breaker import (
-                              CircuitBreaker,
-                              CircuitOpenError,
-                              CircuitState,
-                              circuit_breaker,
-                              get_circuit_breaker,
+    CircuitBreaker,
+    CircuitOpenError,
+    CircuitState,
+    circuit_breaker,
+    get_circuit_breaker,
 )
 from .fallback import Fallback, fallback, with_fallback
 from .health import HealthCheck, HealthStatus, SystemHealth

empathy_os/scaffolding/cli.py

@@ -218,7 +218,7 @@ Examples:
     )
 
     # List patterns command
-    list_parser = subparsers.add_parser("list-patterns", help="List available patterns")
+    subparsers.add_parser("list-patterns", help="List available patterns")
 
     args = parser.parse_args()
 

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/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,7 +77,7 @@ 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 = []
 
@@ -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,13 +353,10 @@ 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)
@@ -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__ = [