empathy-framework 4.7.0__py3-none-any.whl → 4.8.0__py3-none-any.whl

empathy_os/models/registry.py

@@ -31,14 +31,9 @@ class ModelTier(Enum):
 
 
 class ModelProvider(Enum):
-    """Supported model providers."""
+    """Supported model provider (Claude-native architecture as of v5.0.0)."""
 
     ANTHROPIC = "anthropic"
-    OPENAI = "openai"
-    GOOGLE = "google"
-    OLLAMA = "ollama"
-    HYBRID = "hybrid"
-    CUSTOM = "custom"
 
 
 @dataclass(frozen=True)
@@ -164,156 +159,6 @@ MODEL_REGISTRY: dict[str, dict[str, ModelInfo]] = {
             supports_tools=True,
         ),
     },
-    # -------------------------------------------------------------------------
-    # OpenAI Models
-    # -------------------------------------------------------------------------
-    "openai": {
-        "cheap": ModelInfo(
-            id="gpt-4o-mini",
-            provider="openai",
-            tier="cheap",
-            input_cost_per_million=0.15,
-            output_cost_per_million=0.60,
-            max_tokens=4096,
-            supports_vision=False,
-            supports_tools=True,
-        ),
-        "capable": ModelInfo(
-            id="gpt-4o",
-            provider="openai",
-            tier="capable",
-            input_cost_per_million=2.50,
-            output_cost_per_million=10.00,
-            max_tokens=4096,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-        "premium": ModelInfo(
-            id="o1",
-            provider="openai",
-            tier="premium",
-            input_cost_per_million=15.00,
-            output_cost_per_million=60.00,
-            max_tokens=32768,
-            supports_vision=False,
-            supports_tools=False,  # o1 doesn't support tools yet
-        ),
-    },
-    # -------------------------------------------------------------------------
-    # Google Gemini Models
-    # Key feature: Massive context windows (1M-2M tokens)
-    # Model recommendations by tier:
-    #   cheap: gemini-2.0-flash-exp (1M context, fast, very cheap)
-    #   capable: gemini-1.5-pro (2M context, excellent for large codebases)
-    #   premium: gemini-2.5-pro (Google's most capable reasoning model)
-    # -------------------------------------------------------------------------
-    "google": {
-        "cheap": ModelInfo(
-            id="gemini-2.0-flash-exp",
-            provider="google",
-            tier="cheap",
-            input_cost_per_million=0.10,
-            output_cost_per_million=0.40,
-            max_tokens=8192,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-        "capable": ModelInfo(
-            id="gemini-1.5-pro",
-            provider="google",
-            tier="capable",
-            input_cost_per_million=1.25,
-            output_cost_per_million=5.00,
-            max_tokens=8192,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-        "premium": ModelInfo(
-            id="gemini-2.5-pro",
-            provider="google",
-            tier="premium",
-            input_cost_per_million=1.25,
-            output_cost_per_million=10.00,
-            max_tokens=8192,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-    },
-    # -------------------------------------------------------------------------
-    # Ollama (Local) Models - Zero cost
-    # Model recommendations by tier:
-    #   cheap: Small, fast models (3B params) - llama3.2:3b
-    #   capable: Mid-size models (8B params) - llama3.1:8b
-    #   premium: Large models (70B params) - llama3.1:70b
-    # Users need to pull models: ollama pull llama3.2:3b llama3.1:8b llama3.1:70b
-    # -------------------------------------------------------------------------
-    "ollama": {
-        "cheap": ModelInfo(
-            id="llama3.2:3b",
-            provider="ollama",
-            tier="cheap",
-            input_cost_per_million=0.0,
-            output_cost_per_million=0.0,
-            max_tokens=4096,
-            supports_vision=False,
-            supports_tools=True,
-        ),
-        "capable": ModelInfo(
-            id="llama3.1:8b",
-            provider="ollama",
-            tier="capable",
-            input_cost_per_million=0.0,
-            output_cost_per_million=0.0,
-            max_tokens=8192,
-            supports_vision=False,
-            supports_tools=True,
-        ),
-        "premium": ModelInfo(
-            id="llama3.1:70b",
-            provider="ollama",
-            tier="premium",
-            input_cost_per_million=0.0,
-            output_cost_per_million=0.0,
-            max_tokens=8192,
-            supports_vision=False,
-            supports_tools=True,
-        ),
-    },
-    # -------------------------------------------------------------------------
-    # Hybrid - Mix of best models from different providers
-    # -------------------------------------------------------------------------
-    "hybrid": {
-        "cheap": ModelInfo(
-            id="gpt-4o-mini",  # OpenAI - cheapest per token
-            provider="openai",
-            tier="cheap",
-            input_cost_per_million=0.15,
-            output_cost_per_million=0.60,
-            max_tokens=4096,
-            supports_vision=False,
-            supports_tools=True,
-        ),
-        "capable": ModelInfo(
-            id="claude-sonnet-4-5",  # Anthropic Sonnet 4.5 - best reasoning (2026)
-            provider="anthropic",
-            tier="capable",
-            input_cost_per_million=3.00,
-            output_cost_per_million=15.00,
-            max_tokens=8192,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-        "premium": ModelInfo(
-            id="claude-opus-4-5-20251101",  # Anthropic - best overall
-            provider="anthropic",
-            tier="premium",
-            input_cost_per_million=15.00,
-            output_cost_per_million=75.00,
-            max_tokens=8192,
-            supports_vision=True,
-            supports_tools=True,
-        ),
-    },
 }
 
 
@@ -364,11 +209,11 @@ class ModelRegistry:
         """Build tier and model ID caches for O(1) lookups."""
         # Cache for get_models_by_tier (tier -> list[ModelInfo])
         self._tier_cache: dict[str, list[ModelInfo]] = {}
-        for tier_value in [t.value for t in ModelTier]:
-            self._tier_cache[tier_value] = [
-                provider_models[tier_value]
+        for tier in ModelTier:
+            self._tier_cache[tier.value] = [
+                provider_models[tier.value]
                 for provider_models in self._registry.values()
-                if tier_value in provider_models
+                if tier.value in provider_models
             ]
 
         # Cache for get_model_by_id (model_id -> ModelInfo)
@@ -381,23 +226,30 @@ class ModelRegistry:
         """Get model info for a provider/tier combination.
 
         Args:
-            provider: Provider name (anthropic, openai, google, ollama, hybrid)
+            provider: Provider name (anthropic only as of v5.0.0)
             tier: Tier level (cheap, capable, premium)
 
         Returns:
             ModelInfo if found, None otherwise
 
+        Raises:
+            ValueError: If provider is not 'anthropic'
+
         Example:
             >>> registry = ModelRegistry()
             >>> model = registry.get_model("anthropic", "capable")
             >>> print(model.id)
             claude-sonnet-4-5
 
-            >>> model = registry.get_model("openai", "cheap")
-            >>> print(model.cost_per_1k_input)
-            0.00015
-
         """
+        if provider.lower() != "anthropic":
+            raise ValueError(
+                f"Provider '{provider}' is not supported. "
+                f"Empathy Framework is now Claude-native (v5.0.0). "
+                f"Only 'anthropic' provider is available. "
+                f"See docs/CLAUDE_NATIVE.md for migration guide."
+            )
+
         provider_models = self._registry.get(provider.lower())
         if provider_models is None:
             return None
@@ -430,7 +282,7 @@ class ModelRegistry:
         return self._model_id_cache.get(model_id)
 
     def get_models_by_tier(self, tier: str) -> list[ModelInfo]:
-        """Get all models in a specific tier across all providers.
+        """Get all models in a specific tier (Anthropic-only as of v5.0.0).
 
         Uses O(1) cache lookup for fast performance.
 
@@ -444,33 +296,29 @@ class ModelRegistry:
             >>> registry = ModelRegistry()
             >>> cheap_models = registry.get_models_by_tier("cheap")
             >>> print(len(cheap_models))
-            5
+            1
             >>> print([m.provider for m in cheap_models])
-            ['anthropic', 'openai', 'google', 'ollama', 'openai']
+            ['anthropic']
 
             >>> premium_models = registry.get_models_by_tier("premium")
             >>> for model in premium_models:
             ...     print(f"{model.provider}: {model.id}")
             anthropic: claude-opus-4-5-20251101
-            openai: o1
-            google: gemini-2.5-pro
-            ollama: llama3.1:70b
-            anthropic: claude-opus-4-5-20251101
 
         """
         return self._tier_cache.get(tier.lower(), [])
 
     def list_providers(self) -> list[str]:
-        """Get list of all provider names.
+        """Get list of all provider names (Anthropic-only as of v5.0.0).
 
         Returns:
-            List of provider names (e.g., ['anthropic', 'openai', ...])
+            List of provider names (['anthropic'])
 
         Example:
             >>> registry = ModelRegistry()
             >>> providers = registry.list_providers()
             >>> print(providers)
-            ['anthropic', 'openai', 'google', 'ollama', 'hybrid']
+            ['anthropic']
 
         """
         return list(self._registry.keys())
@@ -491,7 +339,7 @@ class ModelRegistry:
         return [tier.value for tier in ModelTier]
 
     def get_all_models(self) -> dict[str, dict[str, ModelInfo]]:
-        """Get the complete model registry.
+        """Get the complete model registry (Anthropic-only as of v5.0.0).
 
         Returns:
             Full registry dict (provider -> tier -> ModelInfo)
@@ -500,7 +348,7 @@ class ModelRegistry:
             >>> registry = ModelRegistry()
             >>> all_models = registry.get_all_models()
             >>> print(all_models.keys())
-            dict_keys(['anthropic', 'openai', 'google', 'ollama', 'hybrid'])
+            dict_keys(['anthropic'])
 
         """
         return self._registry
@@ -520,9 +368,9 @@ class ModelRegistry:
             >>> print(pricing)
             {'input': 3.0, 'output': 15.0}
 
-            >>> pricing = registry.get_pricing_for_model("gpt-4o-mini")
+            >>> pricing = registry.get_pricing_for_model("claude-opus-4-5-20251101")
             >>> print(f"${pricing['input']}/M input, ${pricing['output']}/M output")
-            $0.15/M input, $0.6/M output
+            $15.0/M input, $75.0/M output
 
         """
         model = self.get_model_by_id(model_id)
@@ -549,12 +397,15 @@ def get_model(provider: str, tier: str) -> ModelInfo | None:
     """Get model info for a provider/tier combination.
 
     Args:
-        provider: Provider name (anthropic, openai, ollama, hybrid)
+        provider: Provider name (anthropic only as of v5.0.0)
         tier: Tier level (cheap, capable, premium)
 
     Returns:
         ModelInfo if found, None otherwise
 
+    Raises:
+        ValueError: If provider is not 'anthropic'
+
     Note:
         This is a convenience wrapper around the default ModelRegistry instance.
         For more features, consider using ModelRegistry directly.

empathy_os/monitoring/alerts.py

@@ -117,15 +117,15 @@ def _validate_webhook_url(url: str) -> str:
     # Block common internal service ports
     if parsed.port is not None:
         blocked_ports = {
-            22,     # SSH
-            23,     # Telnet
-            3306,   # MySQL
-            5432,   # PostgreSQL
-            6379,   # Redis
+            22,  # SSH
+            23,  # Telnet
+            3306,  # MySQL
+            5432,  # PostgreSQL
+            6379,  # Redis
             27017,  # MongoDB
-            9200,   # Elasticsearch
-            2379,   # etcd
-            8500,   # Consul
+            9200,  # Elasticsearch
+            2379,  # etcd
+            8500,  # Consul
         }
         if parsed.port in blocked_ports:
             raise ValueError(
@@ -208,9 +208,9 @@ class AlertConfig:
             enabled=data.get("enabled", True),
             cooldown_seconds=data.get("cooldown_seconds", 3600),
             severity=AlertSeverity(data.get("severity", "warning")),
-            created_at=datetime.fromisoformat(data["created_at"])
-            if data.get("created_at")
-            else None,
+            created_at=(
+                datetime.fromisoformat(data["created_at"]) if data.get("created_at") else None
+            ),
         )
 
 
@@ -276,9 +276,7 @@ class AlertEngine:
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
 
         self.telemetry_dir = (
-            Path(telemetry_dir)
-            if telemetry_dir
-            else Path.home() / ".empathy" / "telemetry"
+            Path(telemetry_dir) if telemetry_dir else Path.home() / ".empathy" / "telemetry"
         )
 
         self._cooldown_cache: dict[str, float] = {}  # alert_id -> last_triggered_time
@@ -529,9 +527,7 @@ class AlertEngine:
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
 
-        cursor.execute(
-            "UPDATE alerts SET enabled = ? WHERE id = ?", (int(enabled), alert_id)
-        )
+        cursor.execute("UPDATE alerts SET enabled = ? WHERE id = ?", (int(enabled), alert_id))
         updated = cursor.rowcount > 0
 
         conn.commit()
@@ -577,9 +573,7 @@ class AlertEngine:
                         continue
                     try:
                         entry = json.loads(line)
-                        timestamp = datetime.fromisoformat(
-                            entry.get("timestamp", "2000-01-01")
-                        )
+                        timestamp = datetime.fromisoformat(entry.get("timestamp", "2000-01-01"))
                         if timestamp < cutoff:
                             continue
 

empathy_os/monitoring/alerts_cli.py

@@ -35,7 +35,9 @@ def alerts():
 
 @alerts.command()
 @click.option("--non-interactive", is_flag=True, help="Skip interactive prompts")
-@click.option("--metric", type=click.Choice(["daily_cost", "error_rate", "avg_latency", "token_usage"]))
+@click.option(
+    "--metric", type=click.Choice(["daily_cost", "error_rate", "avg_latency", "token_usage"])
+)
 @click.option("--threshold", type=float)
 @click.option("--channel", type=click.Choice(["webhook", "email", "stdout"]))
 @click.option("--webhook-url", help="Webhook URL (for webhook channel)")
@@ -52,7 +54,9 @@ def init(
     if non_interactive:
         # Non-interactive mode - require all parameters
         if not all([metric, threshold, channel]):
-            click.echo("Error: --metric, --threshold, and --channel required in non-interactive mode")
+            click.echo(
+                "Error: --metric, --threshold, and --channel required in non-interactive mode"
+            )
             sys.exit(1)
 
         if channel == "webhook" and not webhook_url:
@@ -181,6 +185,7 @@ def list_cmd(as_json: bool):
 
     if as_json:
         import json
+
         click.echo(json.dumps([a.to_dict() for a in alerts_list], indent=2))
         return
 
@@ -257,14 +262,18 @@ def watch(interval: int, daemon: bool, once: bool):
         if events:
             click.echo(f"\n⚠️  {len(events)} alert(s) triggered!")
             for event in events:
-                click.echo(f"   - {event.alert_name}: {event.current_value:.2f} >= {event.threshold:.2f}")
+                click.echo(
+                    f"   - {event.alert_name}: {event.current_value:.2f} >= {event.threshold:.2f}"
+                )
         else:
             click.echo("✅ All metrics within thresholds")
         return
 
     if daemon:
         click.echo("🔄 Starting alert watcher as daemon...")
-        click.echo("⚠️  Daemon mode runs in background. Use 'ps aux | grep empathy' to check status.")
+        click.echo(
+            "⚠️  Daemon mode runs in background. Use 'ps aux | grep empathy' to check status."
+        )
         # Daemonize
         _daemonize()
 
@@ -294,11 +303,15 @@ def watch(interval: int, daemon: bool, once: bool):
                 triggered_count += len(events)
                 for event in events:
                     click.echo(f"⚠️  ALERT: {event.alert_name}")
-                    click.echo(f"   {event.metric.value}: {event.current_value:.2f} >= {event.threshold:.2f}")
+                    click.echo(
+                        f"   {event.metric.value}: {event.current_value:.2f} >= {event.threshold:.2f}"
+                    )
 
             # Status update every 5 checks
             if check_count % 5 == 0:
-                click.echo(f"   [Check #{check_count}] Monitoring... ({triggered_count} alerts triggered)")
+                click.echo(
+                    f"   [Check #{check_count}] Monitoring... ({triggered_count} alerts triggered)"
+                )
 
             time.sleep(interval)
     except KeyboardInterrupt:
@@ -367,6 +380,7 @@ def history(alert_id: str | None, limit: int, as_json: bool):
 
     if as_json:
         import json
+
         click.echo(json.dumps(records, indent=2))
         return
 
@@ -375,7 +389,9 @@ def history(alert_id: str | None, limit: int, as_json: bool):
     for record in records:
         delivered = "✓" if record["delivered"] else "✗"
         click.echo(f"  [{delivered}] {record['alert_id']}")
-        click.echo(f"    Metric: {record['metric']} = {record['current_value']:.2f} (threshold: {record['threshold']:.2f})")
+        click.echo(
+            f"    Metric: {record['metric']} = {record['current_value']:.2f} (threshold: {record['threshold']:.2f})"
+        )
         click.echo(f"    Severity: {record['severity']}")
         click.echo(f"    Triggered: {record['triggered_at']}")
         if record.get("delivery_error"):
@@ -392,6 +408,7 @@ def metrics(as_json: bool):
 
     if as_json:
         import json
+
         click.echo(json.dumps(current_metrics, indent=2))
         return
 

empathy_os/project_index/__init__.py

@@ -19,10 +19,12 @@ from .index import ProjectIndex
 from .models import FileRecord, IndexConfig, ProjectSummary
 from .reports import ReportGenerator
 from .scanner import ProjectScanner
+from .scanner_parallel import ParallelProjectScanner
 
 __all__ = [
     "FileRecord",
     "IndexConfig",
+    "ParallelProjectScanner",
     "ProjectIndex",
     "ProjectScanner",
     "ProjectSummary",