Delete config

config/__init__.py

@@ -1,12 +0,0 @@
-"""
-Configuration module for ARF Demo
-"""
-from .settings import Settings, get_settings, ARFMode, SafetyMode, InstallationStatus
-
-__all__ = [
-    "Settings",
-    "get_settings", 
-    "ARFMode",
-    "SafetyMode",
-    "InstallationStatus"
-]

config/scenario_registry.py

@@ -1,155 +0,0 @@
-"""
-Single source of truth for incident scenarios
-"""
-import json
-import yaml
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-import logging
-from functools import lru_cache
-
-logger = logging.getLogger(__name__)
-
-
-class ScenarioRegistry:
-    """Registry for incident scenarios with caching"""
-    
-    _instance = None
-    _scenarios = None
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-    
-    @classmethod
-    @lru_cache(maxsize=1)
-    def load_scenarios(cls) -> Dict[str, Dict[str, Any]]:
-        """
-        Load scenarios from config files with caching
-        
-        Priority:
-        1. scenarios.json in config directory
-        2. scenarios.yaml in config directory
-        3. scenarios.yml in config directory
-        4. Hardcoded scenarios from demo module
-        """
-        from config.settings import settings
-        
-        config_path = Path(settings.scenario_config_path)
-        
-        # Try to load from config directory
-        config_files = [
-            config_path / "scenarios.json",
-            config_path / "scenarios.yaml",
-            config_path / "scenarios.yml",
-        ]
-        
-        for file_path in config_files:
-            if file_path.exists():
-                try:
-                    logger.info(f"Loading scenarios from {file_path}")
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        if file_path.suffix == '.json':
-                            scenarios = json.load(f)
-                        else:
-                            scenarios = yaml.safe_load(f)
-                    
-                    # Validate scenarios
-                    validated = cls._validate_scenarios(scenarios)
-                    logger.info(f"Loaded {len(validated)} scenarios from {file_path}")
-                    return validated
-                except Exception as e:
-                    logger.error(f"Failed to load scenarios from {file_path}: {e}")
-        
-        # Fallback to hardcoded scenarios
-        logger.info("Loading hardcoded scenarios from demo module")
-        from demo.scenarios import INCIDENT_SCENARIOS
-        return INCIDENT_SCENARIOS
-    
-    @classmethod
-    def get_scenario(cls, name: str) -> Dict[str, Any]:
-        """Get scenario by name"""
-        if cls._scenarios is None:
-            cls._scenarios = cls.load_scenarios()
-        
-        scenario = cls._scenarios.get(name)
-        if not scenario:
-            raise ValueError(f"Scenario '{name}' not found")
-        
-        return scenario.copy()  # Return copy to prevent mutation
-    
-    @classmethod
-    def get_all_scenario_names(cls) -> List[str]:
-        """Get all scenario names"""
-        if cls._scenarios is None:
-            cls._scenarios = cls.load_scenarios()
-        
-        return list(cls._scenarios.keys())
-    
-    @classmethod
-    def get_scenario_metrics(cls, scenario_name: str) -> Dict[str, Any]:
-        """Get metrics for a specific scenario"""
-        scenario = cls.get_scenario(scenario_name)
-        return scenario.get("metrics", {})
-    
-    @classmethod
-    def get_scenario_business_impact(cls, scenario_name: str) -> Dict[str, Any]:
-        """Get business impact for a specific scenario"""
-        scenario = cls.get_scenario(scenario_name)
-        return scenario.get("business_impact", {})
-    
-    @classmethod
-    def get_scenario_roi_data(cls, scenario_name: str) -> Dict[str, Any]:
-        """Get ROI data for a specific scenario"""
-        scenario = cls.get_scenario(scenario_name)
-        return scenario.get("roi_data", {})
-    
-    @classmethod
-    def _validate_scenario(cls, scenario: Dict[str, Any]) -> bool:
-        """Validate single scenario"""
-        required_fields = ["description", "severity", "component", "metrics", "business_impact"]
-        
-        # Check required fields
-        for field in required_fields:
-            if field not in scenario:
-                logger.error(f"Missing required field: {field}")
-                return False
-        
-        # Validate severity
-        valid_severities = ["LOW", "MEDIUM", "HIGH", "CRITICAL"]
-        if scenario["severity"] not in valid_severities:
-            logger.error(f"Invalid severity: {scenario['severity']}")
-            return False
-        
-        # Validate metrics (at least one metric required)
-        if not isinstance(scenario["metrics"], dict) or not scenario["metrics"]:
-            logger.error("Metrics must be a non-empty dictionary")
-            return False
-        
-        # Validate business impact
-        if not isinstance(scenario["business_impact"], dict):
-            logger.error("Business impact must be a dictionary")
-            return False
-        
-        return True
-    
-    @classmethod
-    def _validate_scenarios(cls, scenarios: Dict[str, Dict]) -> Dict[str, Dict]:
-        """Validate all scenarios and return valid ones"""
-        validated = {}
-        
-        for name, scenario in scenarios.items():
-            if cls._validate_scenario(scenario):
-                validated[name] = scenario
-            else:
-                logger.warning(f"Skipping invalid scenario: {name}")
-        
-        return validated
-    
-    @classmethod
-    def reload_scenarios(cls) -> None:
-        """Clear cache and reload scenarios"""
-        cls.load_scenarios.cache_clear()
-        cls._scenarios = None
-        logger.info("Scenario cache cleared")

config/scenarios.json

@@ -1,57 +0,0 @@
-{
-  "Cache Miss Storm": {
-    "description": "Redis cluster experiencing 80% cache miss rate causing database overload",
-    "severity": "CRITICAL",
-    "component": "redis_cache",
-    "metrics": {
-      "cache_hit_rate": 18.5,
-      "database_load": 92,
-      "response_time_ms": 1850,
-      "affected_users": 45000,
-      "eviction_rate_per_sec": 125
-    },
-    "business_impact": {
-      "revenue_loss_per_hour": 8500,
-      "sla_violation": true,
-      "customer_sat_change": -40,
-      "affected_services": ["API Gateway", "User Service", "Payment"]
-    },
-    "roi_data": {
-      "hourly_revenue_loss": 8500,
-      "manual_recovery_hours": 1.0,
-      "enterprise_recovery_hours": 0.2,
-      "engineers_required": 4,
-      "engineer_hourly_rate": 150,
-      "estimated_monthly_occurrences": 2,
-      "enterprise_savings_percentage": 0.85
-    }
-  },
-  "Database Connection Pool Exhaustion": {
-    "description": "PostgreSQL connection pool exhausted causing API timeouts",
-    "severity": "HIGH",
-    "component": "postgresql_database",
-    "metrics": {
-      "active_connections": 98,
-      "max_connections": 100,
-      "api_latency_ms": 2450,
-      "error_rate": 15.2,
-      "queue_depth": 1250,
-      "connection_wait_seconds": 45
-    },
-    "business_impact": {
-      "revenue_loss_per_hour": 4200,
-      "affected_services": ["API Gateway", "User Service", "Payment Service"],
-      "sla_violation": true,
-      "partner_api_impact": 3
-    },
-    "roi_data": {
-      "hourly_revenue_loss": 4200,
-      "manual_recovery_hours": 0.75,
-      "enterprise_recovery_hours": 0.13,
-      "engineers_required": 2,
-      "engineer_hourly_rate": 150,
-      "estimated_monthly_occurrences": 3,
-      "enterprise_savings_percentage": 0.82
-    }
-  }
-}

config/scenarios.yaml

@@ -1,150 +0,0 @@
-Cache Miss Storm:
-  description: "Redis cluster experiencing 80% cache miss rate causing database overload"
-  severity: "CRITICAL"
-  component: "redis_cache"
-  metrics:
-    cache_hit_rate: 18.5
-    database_load: 92
-    response_time_ms: 1850
-    affected_users: 45000
-    eviction_rate_per_sec: 125
-  business_impact:
-    revenue_loss_per_hour: 8500
-    sla_violation: true
-    customer_sat_change: -40
-    affected_services:
-      - "API Gateway"
-      - "User Service"
-      - "Payment"
-  roi_data:
-    hourly_revenue_loss: 8500
-    manual_recovery_hours: 1.0
-    enterprise_recovery_hours: 0.2
-    engineers_required: 4
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 2
-    enterprise_savings_percentage: 0.85
-
-Database Connection Pool Exhaustion:
-  description: "PostgreSQL connection pool exhausted causing API timeouts"
-  severity: "HIGH"
-  component: "postgresql_database"
-  metrics:
-    active_connections: 98
-    max_connections: 100
-    api_latency_ms: 2450
-    error_rate: 15.2
-    queue_depth: 1250
-    connection_wait_seconds: 45
-  business_impact:
-    revenue_loss_per_hour: 4200
-    affected_services:
-      - "API Gateway"
-      - "User Service"
-      - "Payment Service"
-    sla_violation: true
-    partner_api_impact: 3
-  roi_data:
-    hourly_revenue_loss: 4200
-    manual_recovery_hours: 0.75
-    enterprise_recovery_hours: 0.13
-    engineers_required: 2
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 3
-    enterprise_savings_percentage: 0.82
-
-Kubernetes Memory Leak:
-  description: "Java microservice memory leak causing pod restarts"
-  severity: "HIGH"
-  component: "java_payment_service"
-  metrics:
-    memory_usage: 96
-    gc_pause_time_ms: 4500
-    error_rate: 28.5
-    restart_frequency_per_hour: 12
-    heap_fragmentation: 42
-  business_impact:
-    revenue_loss_per_hour: 5500
-    session_loss: 8500
-    payment_failures_percentage: 3.2
-    support_tickets_increase: 300
-  roi_data:
-    hourly_revenue_loss: 5500
-    manual_recovery_hours: 1.5
-    enterprise_recovery_hours: 0.25
-    engineers_required: 3
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 1
-    enterprise_savings_percentage: 0.79
-
-API Rate Limit Storm:
-  description: "Third-party API rate limiting causing cascading failures"
-  severity: "MEDIUM"
-  component: "external_api_gateway"
-  metrics:
-    rate_limit_hits_percentage: 95
-    error_rate: 42.8
-    retry_storm: true
-    cascade_effect_services: 3
-    queue_backlog: 8500
-  business_impact:
-    revenue_loss_per_hour: 3800
-    partner_sla_breach: true
-    data_sync_delay_hours: 4
-    customer_reports_delay_hours: 6
-  roi_data:
-    hourly_revenue_loss: 3800
-    manual_recovery_hours: 1.25
-    enterprise_recovery_hours: 0.17
-    engineers_required: 3
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 4
-    enterprise_savings_percentage: 0.85
-
-Network Partition:
-  description: "Network partition causing split-brain in distributed database"
-  severity: "CRITICAL"
-  component: "distributed_database"
-  metrics:
-    partition_detected: true
-    write_conflicts: 1250
-    data_inconsistency_percentage: 8.5
-    replication_lag_seconds: 45
-    quorum_lost: true
-  business_impact:
-    revenue_loss_per_hour: 12000
-    data_corruption_risk: true
-    recovery_complexity: "HIGH"
-    compliance_violation: true
-  roi_data:
-    hourly_revenue_loss: 12000
-    manual_recovery_hours: 2.0
-    enterprise_recovery_hours: 0.3
-    engineers_required: 5
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 0.5
-    enterprise_savings_percentage: 0.88
-
-Storage I/O Saturation:
-  description: "Storage system I/O saturation causing application timeouts"
-  severity: "HIGH"
-  component: "storage_cluster"
-  metrics:
-    io_utilization: 98
-    latency_ms: 450
-    throughput_mbps: 1250
-    queue_depth: 850
-    error_rate: 8.5
-  business_impact:
-    revenue_loss_per_hour: 6800
-    data_processing_delay_hours: 3
-    analytics_backlog: true
-    reporting_failure: true
-  roi_data:
-    hourly_revenue_loss: 6800
-    manual_recovery_hours: 1.75
-    enterprise_recovery_hours: 0.22
-    engineers_required: 3
-    engineer_hourly_rate: 150
-    estimated_monthly_occurrences: 1.5
-    enterprise_savings_percentage: 0.83

config/settings.py

@@ -1,318 +0,0 @@
-"""
-ARF Settings Configuration with Pydantic 2.x Compatibility
-Fixed for both OSS and Enterprise deployments - FIXED VERSION CONSISTENCY
-"""
-import os
-import sys
-from enum import Enum
-from typing import Optional, Dict, Any, List, Union
-from datetime import datetime
-
-# Try to import pydantic with version detection
-try:
-    from pydantic import Field, validator, model_validator
-    from pydantic_settings import BaseSettings, SettingsConfigDict
-    PYDANTIC_V2 = True
-except ImportError:
-    # Fallback for pydantic v1
-    from pydantic import Field, validator
-    from pydantic_settings import BaseSettings
-    PYDANTIC_V2 = False
-
-import logging
-logger = logging.getLogger(__name__)
-
-# Enums for ARF modes
-class ARFMode(str, Enum):
-    """ARF Operational Modes"""
-    DEMO = "demo"
-    OSS = "oss"
-    ENTERPRISE = "enterprise"
-    HYBRID = "hybrid"
-    SIMULATION = "simulation"
-
-class SafetyMode(str, Enum):
-    """Safety and Compliance Modes"""
-    STANDARD = "standard"
-    STRICT = "strict"
-    PERMISSIVE = "permissive"
-    ENTERPRISE = "enterprise"
-    COMPLIANCE = "compliance"
-
-class InstallationStatus(str, Enum):
-    """Package Installation Status"""
-    NOT_INSTALLED = "not_installed"
-    OSS_ONLY = "oss_only"
-    ENTERPRISE_ONLY = "enterprise_only"
-    FULL_INSTALL = "full_install"
-    DEMO_MODE = "demo_mode"
-
-# Pydantic 2.x compatible Settings class
-if PYDANTIC_V2:
-    class Settings(BaseSettings):
-        """ARF Settings with Pydantic 2.x compatibility - FIXED: Version consistency"""
-        model_config = SettingsConfigDict(
-            env_file=".env",
-            env_file_encoding="utf-8",
-            env_prefix="ARF_",
-            case_sensitive=False,
-            extra="ignore"
-        )
-        
-        # Core Settings
-        arf_mode: ARFMode = Field(default=ARFMode.DEMO, description="ARF operational mode")
-        safety_mode: SafetyMode = Field(default=SafetyMode.STANDARD, description="Safety compliance mode")
-        debug: bool = Field(default=False, description="Enable debug logging")
-        log_level: str = Field(default="INFO", description="Logging level")
-        
-        # Version Info - FIXED: Updated to v3.3.9 (actual PyPI version)
-        arf_version: str = Field(default="3.3.9", description="ARF version")
-        demo_version: str = Field(default="3.8.0", description="Demo app version")
-        
-        # Installation Status
-        oss_installed: bool = Field(default=False, description="ARF OSS package installed")
-        enterprise_installed: bool = Field(default=False, description="Enterprise package installed")
-        installation_status: InstallationStatus = Field(
-            default=InstallationStatus.DEMO_MODE,
-            description="Overall installation status"
-        )
-        
-        # Feature Flags
-        enable_telemetry: bool = Field(default=True, description="Enable telemetry collection")
-        enable_anomaly_detection: bool = Field(default=True, description="Enable anomaly detection")
-        enable_business_metrics: bool = Field(default=True, description="Enable business metrics")
-        enable_audit_trail: bool = Field(default=True, description="Enable audit trail")
-        
-        # Paths
-        data_dir: str = Field(default="./data", description="Data directory")
-        log_dir: str = Field(default="./logs", description="Log directory")
-        cache_dir: str = Field(default="./cache", description="Cache directory")
-        scenario_config_path: str = Field(default="./config/scenarios", description="Path to scenario configuration files")
-        
-        # API Settings
-        api_timeout: int = Field(default=30, description="API timeout in seconds")
-        max_retries: int = Field(default=3, description="Maximum API retries")
-        rate_limit: int = Field(default=100, description="API rate limit per minute")
-        
-        # UI Settings
-        ui_theme: str = Field(default="dark", description="UI theme")
-        refresh_interval: int = Field(default=5, description="UI refresh interval in seconds")
-        
-        # Business Settings
-        default_currency: str = Field(default="USD", description="Default currency")
-        cost_per_incident: float = Field(default=10000.0, description="Default cost per incident")
-        engineer_hourly_rate: float = Field(default=150.0, description="Engineer hourly rate")
-        engineer_annual_cost: float = Field(default=200000.0, description="Engineer annual cost")
-        
-        @model_validator(mode='before')
-        @classmethod
-        def validate_enums(cls, data: Any) -> Any:
-            """Validate and convert enum fields from strings"""
-            if isinstance(data, dict):
-                # Convert string values to enums if needed
-                if 'arf_mode' in data and isinstance(data['arf_mode'], str):
-                    try:
-                        data['arf_mode'] = ARFMode(data['arf_mode'].lower())
-                    except ValueError:
-                        data['arf_mode'] = ARFMode.DEMO
-                
-                if 'safety_mode' in data and isinstance(data['safety_mode'], str):
-                    try:
-                        data['safety_mode'] = SafetyMode(data['safety_mode'].lower())
-                    except ValueError:
-                        data['safety_mode'] = SafetyMode.STANDARD
-                
-                if 'installation_status' in data and isinstance(data['installation_status'], str):
-                    try:
-                        data['installation_status'] = InstallationStatus(data['installation_status'].lower())
-                    except ValueError:
-                        data['installation_status'] = InstallationStatus.DEMO_MODE
-            return data
-        
-        @model_validator(mode='after')
-        def check_installation_status(self):
-            """Update installation status based on detected packages"""
-            # Check if OSS is installed
-            try:
-                import agentic_reliability_framework
-                self.oss_installed = True
-            except ImportError:
-                self.oss_installed = False
-            
-            # Check if Enterprise is installed
-            try:
-                import agentic_reliability_enterprise
-                self.enterprise_installed = True
-            except ImportError:
-                self.enterprise_installed = False
-            
-            # Update installation status
-            if self.oss_installed and self.enterprise_installed:
-                self.installation_status = InstallationStatus.FULL_INSTALL
-            elif self.oss_installed:
-                self.installation_status = InstallationStatus.OSS_ONLY
-            elif self.enterprise_installed:
-                self.installation_status = InstallationStatus.ENTERPRISE_ONLY
-            else:
-                self.installation_status = InstallationStatus.DEMO_MODE
-            
-            return self
-
-else:
-    # Pydantic v1 compatible Settings class
-    class Settings(BaseSettings):
-        """ARF Settings with Pydantic v1 compatibility - FIXED: Version consistency"""
-        class Config:
-            env_file = ".env"
-            env_file_encoding = "utf-8"
-            env_prefix = "ARF_"
-            case_sensitive = False
-        
-        # Core Settings
-        arf_mode: ARFMode = Field(default=ARFMode.DEMO, description="ARF operational mode")
-        safety_mode: SafetyMode = Field(default=SafetyMode.STANDARD, description="Safety compliance mode")
-        debug: bool = Field(default=False, description="Enable debug logging")
-        log_level: str = Field(default="INFO", description="Logging level")
-        
-        # Version Info - FIXED: Updated to v3.3.9 (actual PyPI version)
-        arf_version: str = Field(default="3.3.9", description="ARF version")
-        demo_version: str = Field(default="3.8.0", description="Demo app version")
-        
-        # Installation Status
-        oss_installed: bool = Field(default=False, description="ARF OSS package installed")
-        enterprise_installed: bool = Field(default=False, description="Enterprise package installed")
-        installation_status: InstallationStatus = Field(
-            default=InstallationStatus.DEMO_MODE,
-            description="Overall installation status"
-        )
-        
-        # Feature Flags
-        enable_telemetry: bool = Field(default=True, description="Enable telemetry collection")
-        enable_anomaly_detection: bool = Field(default=True, description="Enable anomaly detection")
-        enable_business_metrics: bool = Field(default=True, description="Enable business metrics")
-        enable_audit_trail: bool = Field(default=True, description="Enable audit trail")
-        
-        # Paths
-        data_dir: str = Field(default="./data", description="Data directory")
-        log_dir: str = Field(default="./logs", description="Log directory")
-        cache_dir: str = Field(default="./cache", description="Cache directory")
-        scenario_config_path: str = Field(default="./config/scenarios", description="Path to scenario configuration files")
-        
-        # API Settings
-        api_timeout: int = Field(default=30, description="API timeout in seconds")
-        max_retries: int = Field(default=3, description="Maximum API retries")
-        rate_limit: int = Field(default=100, description="API rate limit per minute")
-        
-        # UI Settings
-        ui_theme: str = Field(default="dark", description="UI theme")
-        refresh_interval: int = Field(default=5, description="UI refresh interval in seconds")
-        
-        # Business Settings
-        default_currency: str = Field(default="USD", description="Default currency")
-        cost_per_incident: float = Field(default=10000.0, description="Default cost per incident")
-        engineer_hourly_rate: float = Field(default=150.0, description="Engineer hourly rate")
-        engineer_annual_cost: float = Field(default=200000.0, description="Engineer annual cost")
-        
-        @validator('arf_mode', 'safety_mode', 'installation_status', pre=True)
-        def validate_enum_strings(cls, v, field):
-            """Convert string values to enums"""
-            if isinstance(v, str):
-                try:
-                    if field.name == 'arf_mode':
-                        return ARFMode(v.lower())
-                    elif field.name == 'safety_mode':
-                        return SafetyMode(v.lower())
-                    elif field.name == 'installation_status':
-                        return InstallationStatus(v.lower())
-                except ValueError:
-                    # Return default value
-                    if field.name == 'arf_mode':
-                        return ARFMode.DEMO
-                    elif field.name == 'safety_mode':
-                        return SafetyMode.STANDARD
-                    elif field.name == 'installation_status':
-                        return InstallationStatus.DEMO_MODE
-            return v
-        
-        @validator('installation_status', always=True)
-        def update_installation_status(cls, v, values):
-            """Update installation status based on detected packages"""
-            # Check if OSS is installed
-            try:
-                import agentic_reliability_framework
-                values['oss_installed'] = True
-            except ImportError:
-                values['oss_installed'] = False
-            
-            # Check if Enterprise is installed
-            try:
-                import agentic_reliability_enterprise
-                values['enterprise_installed'] = True
-            except ImportError:
-                values['enterprise_installed'] = False
-            
-            # Determine installation status
-            if values.get('oss_installed') and values.get('enterprise_installed'):
-                return InstallationStatus.FULL_INSTALL
-            elif values.get('oss_installed'):
-                return InstallationStatus.OSS_ONLY
-            elif values.get('enterprise_installed'):
-                return InstallationStatus.ENTERPRISE_ONLY
-            else:
-                return InstallationStatus.DEMO_MODE
-
-# Singleton settings instance
-try:
-    settings = Settings()
-    logger.info("✅ Settings initialized successfully")
-    logger.info(f"📊 ARF Mode: {settings.arf_mode}")
-    logger.info(f"🛡️ Safety Mode: {settings.safety_mode}")
-    logger.info(f"📦 Installation Status: {settings.installation_status}")
-    logger.info(f"🔖 ARF Version: {settings.arf_version}")  # Added version logging
-except Exception as e:
-    logger.error(f"❌ Failed to initialize settings: {e}")
-    # Create fallback settings - FIXED: Updated version to 3.3.9
-    class FallbackSettings:
-        arf_mode = ARFMode.DEMO
-        safety_mode = SafetyMode.STANDARD
-        debug = False
-        log_level = "INFO"
-        arf_version = "3.3.9"  # FIXED: Updated from 3.3.7 to 3.3.9
-        demo_version = "3.8.0"
-        oss_installed = False
-        enterprise_installed = False
-        installation_status = InstallationStatus.DEMO_MODE
-        enable_telemetry = True
-        enable_anomaly_detection = True
-        enable_business_metrics = True
-        enable_audit_trail = True
-        data_dir = "./data"
-        log_dir = "./logs"
-        cache_dir = "./cache"
-        scenario_config_path = "./config/scenarios"
-        api_timeout = 30
-        max_retries = 3
-        rate_limit = 100
-        ui_theme = "dark"
-        refresh_interval = 5
-        default_currency = "USD"
-        cost_per_incident = 10000.0
-        engineer_hourly_rate = 150.0
-        engineer_annual_cost = 200000.0
-    
-    settings = FallbackSettings()
-    logger.warning("⚠️ Using fallback settings due to initialization error")
-
-def get_settings() -> Settings:
-    """Get the settings singleton instance"""
-    return settings
-
-# Export everything
-__all__ = [
-    "Settings",
-    "get_settings",
-    "ARFMode",
-    "SafetyMode",
-    "InstallationStatus",
-    "settings"
-]