Update config/settings.py

config/settings.py

@@ -1,11 +1,12 @@
 """
 Configuration management for ARF Demo
-Updated for Pydantic v2 with pydantic-settings
+Updated with REAL ARF installation detection
 """
 from typing import Optional, Dict, Any, List
 from enum import Enum
 import os
 import logging
+import sys
 
 logger = logging.getLogger(__name__)
 
@@ -55,6 +56,14 @@ class SafetyMode(str, Enum):
     AUTONOMOUS = "autonomous"
 
 
+class InstallationStatus(str, Enum):
+    """ARF package installation status"""
+    NOT_INSTALLED = "not_installed"
+    OSS_ONLY = "oss_only"
+    ENTERPRISE = "enterprise"
+    BOTH = "both"
+
+
 class Settings(BaseSettings):
     """
     Application settings with environment variable support
@@ -66,9 +75,30 @@ class Settings(BaseSettings):
         description="ARF operation mode"
     )
     
-    use_mock_arf: bool = Field(
+    use_true_arf: bool = Field(
         default=True,
-        description="Use mock ARF implementation (for demo mode)"
+        description="Use true ARF integration when available"
+    )
+    
+    # ===== Installation Status (Auto-detected) =====
+    arf_oss_installed: bool = Field(
+        default=False,
+        description="ARF OSS package installed"
+    )
+    
+    arf_enterprise_installed: bool = Field(
+        default=False,
+        description="ARF Enterprise package installed"
+    )
+    
+    arf_oss_version: Optional[str] = Field(
+        default=None,
+        description="ARF OSS version if installed"
+    )
+    
+    arf_enterprise_version: Optional[str] = Field(
+        default=None,
+        description="ARF Enterprise version if installed"
     )
     
     # ===== ARF Configuration =====
@@ -138,12 +168,104 @@ class Settings(BaseSettings):
             raise ValueError("ARF API key required for Enterprise mode")
         return v
     
-    @validator("use_mock_arf")
-    def validate_mock_mode(cls, v: bool, values: Dict[str, Any]) -> bool:
-        if values.get("arf_mode") == ARFMode.DEMO:
-            return True
+    @validator("use_true_arf")
+    def validate_true_arf(cls, v: bool, values: Dict[str, Any]) -> bool:
+        if v and not values.get("arf_oss_installed"):
+            logger.warning("True ARF requested but OSS package not installed. Using mock mode.")
+            return False
         return v
     
+    # ===== Installation Detection =====
+    @classmethod
+    def detect_installation(cls):
+        """Detect ARF package installation"""
+        results = {
+            "oss_installed": False,
+            "enterprise_installed": False,
+            "oss_version": None,
+            "enterprise_version": None
+        }
+        
+        # Check OSS package
+        try:
+            import agentic_reliability_framework as arf_oss
+            results["oss_installed"] = True
+            results["oss_version"] = getattr(arf_oss, '__version__', '3.3.7')
+            logger.info(f"✅ ARF OSS v{results['oss_version']} detected")
+        except ImportError:
+            logger.info("⚠️ ARF OSS not installed - will use mock mode")
+        
+        # Check Enterprise package
+        try:
+            import arf_enterprise
+            results["enterprise_installed"] = True
+            results["enterprise_version"] = getattr(arf_enterprise, '__version__', '1.0.2')
+            logger.info(f"✅ ARF Enterprise v{results['enterprise_version']} detected")
+        except ImportError:
+            logger.info("⚠️ ARF Enterprise not installed - will use simulation")
+        
+        return results
+    
+    def get_installation_status(self) -> InstallationStatus:
+        """Get current installation status"""
+        if self.arf_oss_installed and self.arf_enterprise_installed:
+            return InstallationStatus.BOTH
+        elif self.arf_enterprise_installed:
+            return InstallationStatus.ENTERPRISE
+        elif self.arf_oss_installed:
+            return InstallationStatus.OSS_ONLY
+        else:
+            return InstallationStatus.NOT_INSTALLED
+    
+    def get_installation_badges(self) -> Dict[str, Any]:
+        """Get badge information for UI display"""
+        if self.arf_oss_installed:
+            oss_badge = {
+                "text": f"✅ ARF OSS v{self.arf_oss_version}",
+                "color": "#10b981",
+                "icon": "✅"
+            }
+        else:
+            oss_badge = {
+                "text": "⚠️ Mock ARF",
+                "color": "#f59e0b", 
+                "icon": "⚠️"
+            }
+        
+        if self.arf_enterprise_installed:
+            enterprise_badge = {
+                "text": f"🚀 Enterprise v{self.arf_enterprise_version}",
+                "color": "#8b5cf6",
+                "icon": "🚀"
+            }
+        else:
+            enterprise_badge = {
+                "text": "🔒 Enterprise Required",
+                "color": "#64748b",
+                "icon": "🔒"
+            }
+        
+        return {
+            "oss": oss_badge,
+            "enterprise": enterprise_badge
+        }
+    
+    def get_installation_recommendations(self) -> List[str]:
+        """Get installation recommendations"""
+        recommendations = []
+        
+        if not self.arf_oss_installed:
+            recommendations.append(
+                "Install real ARF OSS: `pip install agentic-reliability-framework==3.3.7`"
+            )
+        
+        if not self.arf_enterprise_installed:
+            recommendations.append(
+                "Install ARF Enterprise: `pip install agentic-reliability-enterprise` (requires license)"
+            )
+        
+        return recommendations
+    
     class Config:
         env_file = ".env"
         env_file_encoding = "utf-8"
@@ -151,14 +273,34 @@ class Settings(BaseSettings):
         use_enum_values = True
 
 
-# Global settings instance with fallback
+# Global settings instance with installation detection
 try:
-    settings = Settings()
+    # First detect installation
+    installation_info = Settings.detect_installation()
+    
+    # Create settings with installation info
+    settings = Settings(
+        arf_oss_installed=installation_info["oss_installed"],
+        arf_enterprise_installed=installation_info["enterprise_installed"],
+        arf_oss_version=installation_info["oss_version"],
+        arf_enterprise_version=installation_info["enterprise_version"],
+    )
+    
+    # Log installation status
+    status = settings.get_installation_status()
+    logger.info(f"ARF Installation Status: {status.value}")
+    
+    if status == InstallationStatus.NOT_INSTALLED:
+        logger.warning("No ARF packages installed. Demo will use mock mode.")
+        logger.warning("For real ARF experience, install: pip install agentic-reliability-framework==3.3.7")
+    
 except Exception as e:
-    logger.warning(f"Failed to load settings from .env: {e}, using defaults")
+    logger.warning(f"Failed to load settings: {e}, using defaults")
     settings = Settings(
         arf_mode=ARFMode.DEMO,
-        use_mock_arf=True,
+        use_true_arf=False,
+        arf_oss_installed=False,
+        arf_enterprise_installed=False,
         engineer_hourly_rate=150.0,
         engineer_annual_cost=125000.0,
         default_savings_rate=0.82,
@@ -173,4 +315,32 @@ except Exception as e:
 
 def get_settings() -> Settings:
     """Get settings instance (singleton pattern)"""
-    return settings
+    return settings
+
+
+def print_installation_status():
+    """Print installation status to console"""
+    s = get_settings()
+    status = s.get_installation_status()
+    
+    print("=" * 70)
+    print("🚀 ARF Ultimate Investor Demo - Installation Status")
+    print("=" * 70)
+    
+    print(f"📦 ARF OSS: {'✅ v' + s.arf_oss_version if s.arf_oss_installed else '⚠️ Not installed'}")
+    print(f"🏢 Enterprise: {'✅ v' + s.arf_enterprise_version if s.arf_enterprise_installed else '⚠️ Not installed'}")
+    print(f"🎯 Mode: {s.arf_mode.value}")
+    print(f"🤖 Using True ARF: {'✅ Yes' if s.use_true_arf else '⚠️ Mock mode'}")
+    
+    recommendations = s.get_installation_recommendations()
+    if recommendations:
+        print("\n💡 Recommendations:")
+        for rec in recommendations:
+            print(f"  • {rec}")
+    
+    print("=" * 70)
+
+
+# Print status on import (but only if not in test mode)
+if __name__ != "__main__" and "pytest" not in sys.modules:
+    print_installation_status()