Update app.py

app.py

@@ -32,108 +32,6 @@ logger = logging.getLogger(__name__)
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent))
 
-# ===========================================
-# ARF INSTALLATION CHECK SYSTEM - NEW
-# ===========================================
-def check_arf_installation():
-    """
-    Check if real ARF packages are installed
-    Returns detailed installation status
-    """
-    results = {
-        "oss_installed": False,
-        "enterprise_installed": False,
-        "oss_version": None,
-        "enterprise_version": None,
-        "oss_edition": "unknown",
-        "oss_license": "unknown",
-        "execution_allowed": False,
-        "recommendations": [],
-        "badges": {
-            "oss": {"text": "⚠️ Mock ARF", "color": "#f59e0b", "icon": "⚠️"},
-            "enterprise": {"text": "🔒 Enterprise Required", "color": "#64748b", "icon": "🔒"}
-        },
-        "timestamp": datetime.datetime.now().isoformat()
-    }
-    
-    # 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')
-        
-        # Try to get more info
-        try:
-            results["oss_edition"] = arf_oss.OSS_EDITION
-            results["oss_license"] = arf_oss.OSS_LICENSE
-            results["execution_allowed"] = arf_oss.EXECUTION_ALLOWED
-        except Exception as e:
-            logger.debug(f"Could not get OSS details: {e}")
-            
-        results["badges"]["oss"] = {
-            "text": f"✅ ARF OSS v{results['oss_version']}", 
-            "color": "#10b981", 
-            "icon": "✅"
-        }
-        
-        logger.info(f"✅ ARF OSS v{results['oss_version']} detected")
-        
-    except ImportError as e:
-        results["recommendations"].append(
-            "Install real ARF OSS: `pip install agentic-reliability-framework==3.3.7`"
-        )
-        logger.info("⚠️ ARF OSS not installed - using mock mode")
-    
-    # Check Enterprise package
-    try:
-        import arf_enterprise
-        results["enterprise_installed"] = True
-        results["enterprise_version"] = getattr(arf_enterprise, '__version__', '1.0.2')
-        results["badges"]["enterprise"] = {
-            "text": f"🚀 Enterprise v{results['enterprise_version']}", 
-            "color": "#8b5cf6", 
-            "icon": "🚀"
-        }
-        logger.info(f"✅ ARF Enterprise v{results['enterprise_version']} detected")
-    except ImportError as e:
-        results["recommendations"].append(
-            "Install ARF Enterprise: `pip install agentic-reliability-enterprise` (requires license)"
-        )
-        logger.info("⚠️ ARF Enterprise not installed - using simulation")
-    
-    return results
-
-# Global installation status cache
-_installation_status = None
-
-def get_installation_status():
-    """Get cached installation status"""
-    global _installation_status
-    if _installation_status is None:
-        _installation_status = check_arf_installation()
-    return _installation_status
-
-def get_installation_badges():
-    """Get formatted badge HTML for UI"""
-    installation = get_installation_status()
-    oss_badge = installation["badges"]["oss"]
-    enterprise_badge = installation["badges"]["enterprise"]
-    
-    return f"""
-    <div style="display: flex; justify-content: center; gap: 10px; margin-top: 10px; flex-wrap: wrap;">
-        <span style="padding: 4px 12px; background: {oss_badge['color']}; 
-                    color: white; border-radius: 20px; font-size: 12px; font-weight: bold; 
-                    display: flex; align-items: center; gap: 6px;">
-            {oss_badge['icon']} {oss_badge['text']}
-        </span>
-        <span style="padding: 4px 12px; background: {enterprise_badge['color']}; 
-                    color: white; border-radius: 20px; font-size: 12px; font-weight: bold;
-                    display: flex; align-items: center; gap: 6px;">
-            {enterprise_badge['icon']} {enterprise_badge['text']}
-        </span>
-    </div>
-    """
-
 # ===========================================
 # ASYNC UTILITIES - ENHANCED VERSION
 # ===========================================
@@ -169,16 +67,38 @@ class AsyncRunner:
         return wrapper
 
 # ===========================================
-# SIMPLE SETTINGS
+# SIMPLE SETTINGS - AVOID PYDANTIC ISSUES
 # ===========================================
 class Settings:
-    """Simple settings class"""
+    """Simple settings class that avoids pydantic issues"""
     def __init__(self):
         self.arf_mode = "demo"
         self.use_true_arf = True  # Use true ARF integration
         self.default_scenario = "Cache Miss Storm"
         self.max_history_items = 100
         self.auto_refresh_seconds = 30
+        
+        # Check for real ARF packages
+        self.oss_installed = False
+        self.enterprise_installed = False
+        self.oss_version = None
+        self.enterprise_version = None
+        
+        try:
+            import agentic_reliability_framework as arf_oss
+            self.oss_installed = True
+            self.oss_version = getattr(arf_oss, '__version__', '3.3.7')
+            logger.info(f"✅ ARF OSS v{self.oss_version} detected")
+        except ImportError:
+            logger.info("⚠️ ARF OSS not installed - using mock mode")
+        
+        try:
+            import arf_enterprise
+            self.enterprise_installed = True
+            self.enterprise_version = getattr(arf_enterprise, '__version__', '1.0.2')
+            logger.info(f"✅ ARF Enterprise v{self.enterprise_version} detected")
+        except ImportError:
+            logger.info("⚠️ ARF Enterprise not installed - using simulation")
 
 settings = Settings()
 
@@ -187,43 +107,50 @@ settings = Settings()
 # ===========================================
 def create_empty_plot(title: str):
     """Create an empty placeholder plot"""
-    import plotly.graph_objects as go
-    fig = go.Figure()
-    fig.add_annotation(
-        text="👆 Select a scenario<br>to view data",
-        xref="paper", yref="paper",
-        x=0.5, y=0.5, showarrow=False,
-        font=dict(size=14, color="#64748b")
-    )
-    fig.update_layout(
-        height=300,
-        title=title,
-        paper_bgcolor="rgba(0,0,0,0)",
-        plot_bgcolor="rgba(0,0,0,0)",
-        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
-    )
-    return fig
+    try:
+        import plotly.graph_objects as go
+        fig = go.Figure()
+        fig.add_annotation(
+            text="👆 Select a scenario<br>to view data",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=14, color="#64748b")
+        )
+        fig.update_layout(
+            height=300,
+            title=title,
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+        )
+        return fig
+    except ImportError:
+        # Return None if plotly not available
+        return None
 
 def create_empty_dashboard():
     """Create empty dashboard"""
-    import plotly.graph_objects as go
-    fig = go.Figure()
-    fig.add_annotation(
-        text="📊 Dashboard will populate<br>after ROI calculation",
-        xref="paper", yref="paper",
-        x=0.5, y=0.5, showarrow=False,
-        font=dict(size=16, color="#64748b")
-    )
-    fig.update_layout(
-        height=700,
-        paper_bgcolor="rgba(0,0,0,0)",
-        plot_bgcolor="rgba(0,0,0,0)",
-        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-        title=""
-    )
-    return fig
+    try:
+        import plotly.graph_objects as go
+        fig = go.Figure()
+        fig.add_annotation(
+            text="📊 Dashboard will populate<br>after ROI calculation",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=16, color="#64748b")
+        )
+        fig.update_layout(
+            height=700,
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            title=""
+        )
+        return fig
+    except ImportError:
+        return None
 
 def get_inactive_agent_html(agent_name: str, description: str):
     """Get HTML for inactive agent state"""
@@ -248,77 +175,275 @@ def get_inactive_agent_html(agent_name: str, description: str):
     """
 
 # ===========================================
-# IMPORT MODULAR COMPONENTS - UPDATED FOR TRUE ARF
+# ARF INSTALLATION CHECK SYSTEM - NEW
+# ===========================================
+def check_arf_installation():
+    """
+    Check if real ARF packages are installed
+    Returns detailed installation status
+    """
+    results = {
+        "oss_installed": settings.oss_installed,
+        "enterprise_installed": settings.enterprise_installed,
+        "oss_version": settings.oss_version,
+        "enterprise_version": settings.enterprise_version,
+        "oss_edition": "unknown",
+        "oss_license": "unknown",
+        "execution_allowed": False,
+        "recommendations": [],
+        "badges": {
+            "oss": {"text": "⚠️ Mock ARF", "color": "#f59e0b", "icon": "⚠️"},
+            "enterprise": {"text": "🔒 Enterprise Required", "color": "#64748b", "icon": "🔒"}
+        },
+        "timestamp": datetime.datetime.now().isoformat()
+    }
+    
+    # Check OSS package
+    if settings.oss_installed:
+        results["badges"]["oss"] = {
+            "text": f"✅ ARF OSS v{settings.oss_version}", 
+            "color": "#10b981", 
+            "icon": "✅"
+        }
+        
+        # Try to get more info
+        try:
+            import agentic_reliability_framework as arf_oss
+            results["oss_edition"] = getattr(arf_oss, 'OSS_EDITION', 'oss')
+            results["oss_license"] = getattr(arf_oss, 'OSS_LICENSE', 'Apache 2.0')
+            results["execution_allowed"] = getattr(arf_oss, 'EXECUTION_ALLOWED', False)
+        except Exception as e:
+            logger.debug(f"Could not get OSS details: {e}")
+    else:
+        results["recommendations"].append(
+            "Install real ARF OSS: `pip install agentic-reliability-framework==3.3.7`"
+        )
+    
+    # Check Enterprise package
+    if settings.enterprise_installed:
+        results["badges"]["enterprise"] = {
+            "text": f"🚀 Enterprise v{settings.enterprise_version}", 
+            "color": "#8b5cf6", 
+            "icon": "🚀"
+        }
+    else:
+        results["recommendations"].append(
+            "Install ARF Enterprise: `pip install agentic-reliability-enterprise` (requires license)"
+        )
+    
+    return results
+
+# Global installation status cache
+_installation_status = None
+
+def get_installation_status():
+    """Get cached installation status"""
+    global _installation_status
+    if _installation_status is None:
+        _installation_status = check_arf_installation()
+    return _installation_status
+
+def get_installation_badges():
+    """Get formatted badge HTML for UI"""
+    installation = get_installation_status()
+    oss_badge = installation["badges"]["oss"]
+    enterprise_badge = installation["badges"]["enterprise"]
+    
+    return f"""
+    <div style="display: flex; justify-content: center; gap: 10px; margin-top: 10px; flex-wrap: wrap;">
+        <span style="padding: 4px 12px; background: {oss_badge['color']}; 
+                    color: white; border-radius: 20px; font-size: 12px; font-weight: bold; 
+                    display: flex; align-items: center; gap: 6px;">
+            {oss_badge['icon']} {oss_badge['text']}
+        </span>
+        <span style="padding: 4px 12px; background: {enterprise_badge['color']}; 
+                    color: white; border-radius: 20px; font-size: 12px; font-weight: bold;
+                    display: flex; align-items: center; gap: 6px;">
+            {enterprise_badge['icon']} {enterprise_badge['text']}
+        </span>
+    </div>
+    """
+
+# ===========================================
+# SCENARIO DATA (Fallback if scenarios module fails)
+# ===========================================
+FALLBACK_SCENARIOS = {
+    "Cache Miss Storm": {
+        "component": "Redis Cache Cluster",
+        "severity": "HIGH",
+        "impact_radius": "85% of users",
+        "business_impact": {"revenue_loss_per_hour": 8500},
+        "detection_time": "45 seconds",
+        "tags": ["cache", "redis", "latency"],
+        "metrics": {"affected_users": 45000}
+    },
+    "Database Connection Pool Exhaustion": {
+        "component": "PostgreSQL Connection Pool",
+        "severity": "HIGH",
+        "impact_radius": "Database queries",
+        "business_impact": {"revenue_loss_per_hour": 4200},
+        "detection_time": "30 seconds",
+        "tags": ["database", "connections", "exhaustion"],
+        "metrics": {"affected_queries": 12000}
+    },
+    "Kubernetes Memory Leak": {
+        "component": "K8s Pod Memory",
+        "severity": "MEDIUM",
+        "impact_radius": "Node failure",
+        "business_impact": {"revenue_loss_per_hour": 5500},
+        "detection_time": "60 seconds",
+        "tags": ["kubernetes", "memory", "leak"],
+        "metrics": {"affected_pods": 15}
+    },
+    "API Rate Limit Storm": {
+        "component": "API Gateway",
+        "severity": "MEDIUM",
+        "impact_radius": "API consumers",
+        "business_impact": {"revenue_loss_per_hour": 3800},
+        "detection_time": "25 seconds",
+        "tags": ["api", "rate_limit", "throttling"],
+        "metrics": {"affected_apis": 45}
+    },
+    "Network Partition": {
+        "component": "Network Layer",
+        "severity": "CRITICAL",
+        "impact_radius": "Availability zones",
+        "business_impact": {"revenue_loss_per_hour": 12000},
+        "detection_time": "90 seconds",
+        "tags": ["network", "partition", "availability"],
+        "metrics": {"affected_zones": 2}
+    },
+    "Storage I/O Saturation": {
+        "component": "Storage System",
+        "severity": "HIGH",
+        "impact_radius": "File operations",
+        "business_impact": {"revenue_loss_per_hour": 6800},
+        "detection_time": "40 seconds",
+        "tags": ["storage", "io", "saturation"],
+        "metrics": {"affected_operations": 25000}
+    }
+}
+
+# ===========================================
+# IMPORT MODULAR COMPONENTS - FIXED VERSION
 # ===========================================
 def import_components() -> Dict[str, Any]:
-    """Safely import all components with proper error handling"""
+    """Safely import all components with proper error handling - FIXED"""
     components = {
         "all_available": False,
-        "error": None
+        "error": None,
+        "get_styles": lambda: "",  # Default empty styles
+        "INCIDENT_SCENARIOS": FALLBACK_SCENARIOS  # Default scenarios
     }
     
     try:
+        logger.info("Starting component import...")
+        
         # First, import gradio (always available in Hugging Face Spaces)
-        import gradio as gr
-        components["gr"] = gr
+        try:
+            import gradio as gr
+            components["gr"] = gr
+            logger.info("✅ Gradio imported successfully")
+        except ImportError as e:
+            logger.error(f"❌ Gradio not available: {e}")
+            raise ImportError("Gradio is required but not available")
         
-        # Import scenarios
+        # Import UI styles FIRST (to avoid circular dependencies)
+        try:
+            from ui.styles import get_styles
+            components["get_styles"] = get_styles
+            logger.info("✅ UI styles imported successfully")
+        except ImportError as e:
+            logger.warning(f"⚠️ UI styles not available: {e}")
+            # Use empty styles as fallback
+            components["get_styles"] = lambda: ""
+        
+        # Import UI components
+        try:
+            from ui.components import (
+                create_header, create_status_bar, create_tab1_incident_demo,
+                create_tab2_business_roi, create_tab3_enterprise_features,
+                create_tab4_audit_trail, create_tab5_learning_engine,
+                create_footer
+            )
+            components.update({
+                "create_header": create_header,
+                "create_status_bar": create_status_bar,
+                "create_tab1_incident_demo": create_tab1_incident_demo,
+                "create_tab2_business_roi": create_tab2_business_roi,
+                "create_tab3_enterprise_features": create_tab3_enterprise_features,
+                "create_tab4_audit_trail": create_tab4_audit_trail,
+                "create_tab5_learning_engine": create_tab5_learning_engine,
+                "create_footer": create_footer,
+            })
+            logger.info("✅ UI components imported successfully")
+        except ImportError as e:
+            logger.error(f"❌ UI components not available: {e}")
+            # Create minimal UI fallbacks
+            components.update({
+                "create_header": lambda version="3.3.7", mock=False: gr.HTML(f"<h2>🚀 ARF v{version} Demo</h2>"),
+                "create_status_bar": lambda: gr.HTML("<div>Status Bar</div>"),
+                "create_tab1_incident_demo": lambda *args: [gr.Dropdown()] * 24,
+                "create_tab2_business_roi": lambda *args: [gr.Plot()] * 7,
+                "create_tab3_enterprise_features": lambda: [gr.JSON()] * 8,
+                "create_tab4_audit_trail": lambda: [gr.Button()] * 6,
+                "create_tab5_learning_engine": lambda: [gr.Plot()] * 10,
+                "create_footer": lambda: gr.HTML("<footer>ARF v3.3.7</footer>"),
+            })
+        
+        # Try to import scenarios (but don't fail if it doesn't work)
         try:
             from demo.scenarios import INCIDENT_SCENARIOS
-            logger.info(f"Loaded {len(INCIDENT_SCENARIOS)} scenarios from demo module")
             components["INCIDENT_SCENARIOS"] = INCIDENT_SCENARIOS
+            logger.info(f"✅ Loaded {len(INCIDENT_SCENARIOS)} scenarios from demo module")
         except ImportError as e:
-            logger.warning(f"Demo scenarios not available: {e}")
-            # Create minimal fallback
-            components["INCIDENT_SCENARIOS"] = {
-                "Cache Miss Storm": {
-                    "component": "Redis Cache Cluster",
-                    "severity": "HIGH",
-                    "impact_radius": "85% of users",
-                    "business_impact": {"revenue_loss_per_hour": 8500},
-                    "detection_time": "45 seconds",
-                    "tags": ["cache", "redis", "latency"],
-                    "metrics": {"affected_users": 45000}
-                }
-            }
+            logger.warning(f"⚠️ Demo scenarios not available: {e}, using fallback scenarios")
+            components["INCIDENT_SCENARIOS"] = FALLBACK_SCENARIOS
         
-        # Use TrueARF337Orchestrator for true ARF integration
+        # Try to import TrueARF337Orchestrator
         try:
             from core.true_arf_orchestrator import TrueARF337Orchestrator
             components["DemoOrchestrator"] = TrueARF337Orchestrator
             logger.info("✅ Using TrueARF337Orchestrator with real v3.3.7 integration")
         except ImportError as e:
-            logger.warning(f"TrueARF337Orchestrator not available: {e}")
-            # Fall back to old implementation
+            logger.warning(f"⚠️ TrueARF337Orchestrator not available: {e}")
+            # Fall back to real ARF integration
             try:
                 from core.real_arf_integration import RealARFIntegration
                 components["DemoOrchestrator"] = RealARFIntegration
-                logger.info("⚠️ Falling back to RealARFIntegration")
+                logger.info("✅ Falling back to RealARFIntegration")
             except ImportError as e2:
-                logger.error(f"RealARFIntegration also not available: {e2}")
+                logger.warning(f"⚠️ RealARFIntegration also not available: {e2}")
                 # Create a minimal mock orchestrator
                 class MockOrchestrator:
                     async def analyze_incident(self, scenario_name, scenario_data):
                         return {
-                            "status": "error",
-                            "error": "No orchestrator available",
-                            "scenario": scenario_name
+                            "status": "mock",
+                            "scenario": scenario_name,
+                            "message": "Mock analysis (no real ARF available)"
                         }
                     async def execute_healing(self, scenario_name, mode="autonomous"):
                         return {
-                            "status": "error",
-                            "error": "No orchestrator available",
-                            "scenario": scenario_name
+                            "status": "mock",
+                            "scenario": scenario_name,
+                            "message": "Mock execution (no real ARF available)"
                         }
                 components["DemoOrchestrator"] = MockOrchestrator
+                logger.info("⚠️ Using mock orchestrator")
         
-        # Import ROI calculator
+        # Try to import ROI calculator (but don't let it crash)
         try:
-            from core.calculators import EnhancedROICalculator
-            components["EnhancedROICalculator"] = EnhancedROICalculator()
-            logger.info("EnhancedROICalculator imported successfully")
+            # First, try to import without triggering settings
+            import importlib.util
+            spec = importlib.util.find_spec("core.calculators")
+            if spec is not None:
+                from core.calculators import EnhancedROICalculator
+                components["EnhancedROICalculator"] = EnhancedROICalculator()
+                logger.info("✅ EnhancedROICalculator imported successfully")
+            else:
+                raise ImportError("core.calculators module not found")
         except ImportError as e:
-            logger.warning(f"EnhancedROICalculator not available: {e}")
+            logger.warning(f"⚠️ EnhancedROICalculator not available: {e}")
             class MockCalculator:
                 def calculate_comprehensive_roi(self, **kwargs):
                     return {
@@ -333,14 +458,19 @@ def import_components() -> Dict[str, Any]:
                         }
                     }
             components["EnhancedROICalculator"] = MockCalculator()
+            logger.info("⚠️ Using mock ROI calculator")
         
-        # Import visualizations
+        # Try to import visualization engine (but don't let it crash)
         try:
-            from core.visualizations import EnhancedVisualizationEngine
-            components["EnhancedVisualizationEngine"] = EnhancedVisualizationEngine()
-            logger.info("EnhancedVisualizationEngine imported successfully")
+            spec = importlib.util.find_spec("core.visualizations")
+            if spec is not None:
+                from core.visualizations import EnhancedVisualizationEngine
+                components["EnhancedVisualizationEngine"] = EnhancedVisualizationEngine()
+                logger.info("✅ EnhancedVisualizationEngine imported successfully")
+            else:
+                raise ImportError("core.visualizations module not found")
         except ImportError as e:
-            logger.warning(f"EnhancedVisualizationEngine not available: {e}")
+            logger.warning(f"⚠️ EnhancedVisualizationEngine not available: {e}")
             class MockVisualizationEngine:
                 def create_executive_dashboard(self, data=None):
                     return create_empty_dashboard()
@@ -354,57 +484,25 @@ def import_components() -> Dict[str, Any]:
                 def create_timeline_comparison(self):
                     return create_empty_plot("Timeline Comparison")
             components["EnhancedVisualizationEngine"] = MockVisualizationEngine()
-        
-        # Import UI components
-        try:
-            from ui.components import (
-                create_header, create_status_bar, create_tab1_incident_demo,
-                create_tab2_business_roi, create_tab3_enterprise_features,
-                create_tab4_audit_trail, create_tab5_learning_engine,
-                create_footer
-            )
-            components.update({
-                "create_header": create_header,
-                "create_status_bar": create_status_bar,
-                "create_tab1_incident_demo": create_tab1_incident_demo,
-                "create_tab2_business_roi": create_tab2_business_roi,
-                "create_tab3_enterprise_features": create_tab3_enterprise_features,
-                "create_tab4_audit_trail": create_tab4_audit_trail,
-                "create_tab5_learning_engine": create_tab5_learning_engine,
-                "create_footer": create_footer,
-            })
-            logger.info("UI components imported successfully")
-        except ImportError as e:
-            logger.error(f"UI components not available: {e}")
-            # Create minimal UI fallbacks
-            components.update({
-                "create_header": lambda version="3.3.7", mock=False: gr.HTML(f"<h2>🚀 ARF v{version} TRUE</h2>"),
-                "create_status_bar": lambda: gr.HTML("<div>Status</div>"),
-                "create_tab1_incident_demo": lambda *args: [gr.Dropdown()] * 24,
-                "create_tab2_business_roi": lambda *args: [gr.Plot()] * 7,
-                "create_tab3_enterprise_features": lambda: [gr.JSON()] * 8,
-                "create_tab4_audit_trail": lambda: [gr.Button()] * 6,
-                "create_tab5_learning_engine": lambda: [gr.Plot()] * 10,
-                "create_footer": lambda: gr.HTML("<footer>ARF v3.3.7</footer>"),
-            })
-        
-        # Import styles
-        try:
-            from ui.styles import get_styles
-            components["get_styles"] = get_styles
-        except ImportError as e:
-            logger.warning(f"Styles not available: {e}")
-            components["get_styles"] = lambda: ""
+            logger.info("⚠️ Using mock visualization engine")
         
         components["all_available"] = True
         components["error"] = None
-        logger.info("✅ Successfully imported all modular components with True ARF")
+        logger.info("✅ Successfully imported all modular components")
         
     except Exception as e:
         logger.error(f"❌ CRITICAL IMPORT ERROR: {e}")
         logger.error(traceback.format_exc())
         components["error"] = str(e)
         components["all_available"] = False
+        
+        # Ensure we have minimal components
+        if "gr" not in components:
+            try:
+                import gradio as gr
+                components["gr"] = gr
+            except:
+                pass
     
     return components
 
@@ -534,7 +632,10 @@ def create_telemetry_plot(scenario_name: str):
     """Create a telemetry visualization for the selected scenario"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        return viz_engine.create_telemetry_plot(scenario_name, anomaly_detected=True)
+        plot = viz_engine.create_telemetry_plot(scenario_name, anomaly_detected=True)
+        if plot is None:
+            return create_empty_plot(f"Telemetry: {scenario_name}")
+        return plot
     except Exception as e:
         logger.error(f"Failed to create telemetry plot: {e}")
         return create_empty_plot(f"Telemetry: {scenario_name}")
@@ -543,7 +644,10 @@ def create_impact_plot(scenario_name: str):
     """Create a business impact visualization"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        return viz_engine.create_impact_gauge(scenario_name)
+        plot = viz_engine.create_impact_gauge(scenario_name)
+        if plot is None:
+            return create_empty_plot(f"Impact: {scenario_name}")
+        return plot
     except Exception as e:
         logger.error(f"Failed to create impact plot: {e}")
         return create_empty_plot(f"Impact: {scenario_name}")
@@ -552,7 +656,10 @@ def create_timeline_plot(scenario_name: str):
     """Create an incident timeline visualization"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        return viz_engine.create_timeline_comparison()
+        plot = viz_engine.create_timeline_comparison()
+        if plot is None:
+            return create_empty_plot("Timeline Comparison")
+        return plot
     except Exception as e:
         logger.error(f"Failed to create timeline plot: {e}")
         return create_empty_plot("Timeline Comparison")
@@ -630,8 +737,9 @@ async def run_true_arf_analysis(scenario_name: str):
         installation = get_installation_status()
         real_arf_available = installation["oss_installed"]
         
-        # Use TrueARF337Orchestrator if available
-        orchestrator = get_components()["DemoOrchestrator"]()
+        # Use orchestrator for analysis
+        orchestrator_class = get_components()["DemoOrchestrator"]
+        orchestrator = orchestrator_class()
         analysis = await orchestrator.analyze_incident(scenario_name, scenario)
         
         # Check for errors
@@ -646,8 +754,6 @@ async def run_true_arf_analysis(scenario_name: str):
         incident_table_data = get_audit_manager().get_incident_table()
         
         # Extract values from analysis
-        demo_display = analysis.get("demo_display", {})
-        real_arf_version = demo_display.get("real_arf_version", "mock")
         true_oss_used = analysis.get("true_oss_used", False)
         enterprise_simulated = analysis.get("enterprise_simulated", False)
         
@@ -770,7 +876,7 @@ async def run_true_arf_analysis(scenario_name: str):
             is_real_arf=true_oss_used
         )
         
-        logger.info(f"Analysis completed successfully for {scenario_name} (True ARF: {real_arf_version})")
+        logger.info(f"Analysis completed successfully for {scenario_name}")
         return (
             detection_html, recall_html, decision_html,
             oss_results, incident_table_data
@@ -845,9 +951,10 @@ def create_agent_html(agent_name: str, status: str, metrics: str, is_real_arf: b
 # ===========================================
 def execute_enterprise_healing(scenario_name, approval_required, mcp_mode_value):
     """Execute enterprise healing with true ARF simulation"""
-    import gradio as gr
+    components = get_components()
+    gr = components["gr"]
     
-    scenario = get_components()["INCIDENT_SCENARIOS"].get(scenario_name, {})
+    scenario = components["INCIDENT_SCENARIOS"].get(scenario_name, {})
     
     # Determine mode
     mode = "Approval" if approval_required else "Autonomous"
@@ -895,7 +1002,7 @@ def execute_enterprise_healing(scenario_name, approval_required, mcp_mode_value)
     get_audit_manager().add_execution(scenario_name, mode, savings=savings)
     
     # Get orchestrator for execution simulation
-    orchestrator = get_components()["DemoOrchestrator"]()
+    orchestrator = components["DemoOrchestrator"]()
     
     # Create approval display
     if approval_required:
@@ -1077,16 +1184,76 @@ def execute_enterprise_healing(scenario_name, approval_required, mcp_mode_value)
     
     return gr.HTML.update(value=approval_html), enterprise_results, execution_table_data
 
+# ===========================================
+# ROI CALCULATION FUNCTION
+# ===========================================
+def calculate_roi(scenario_name, monthly_incidents, team_size):
+    """Calculate ROI"""
+    try:
+        logger.info(f"Calculating ROI for {scenario_name}")
+        
+        # Validate inputs
+        monthly_incidents = int(monthly_incidents) if monthly_incidents else 15
+        team_size = int(team_size) if team_size else 5
+        
+        # Get scenario-specific impact
+        avg_impact = get_scenario_impact(scenario_name)
+        
+        # Calculate ROI
+        roi_calculator = get_components()["EnhancedROICalculator"]
+        roi_result = roi_calculator.calculate_comprehensive_roi(
+            monthly_incidents=monthly_incidents,
+            avg_impact=float(avg_impact),
+            team_size=team_size
+        )
+        
+        # Extract ROI multiplier for visualization
+        roi_multiplier = extract_roi_multiplier(roi_result)
+        
+        # Create visualization
+        viz_engine = get_components()["EnhancedVisualizationEngine"]
+        chart = viz_engine.create_executive_dashboard({"roi_multiplier": roi_multiplier})
+        
+        return roi_result, chart
+        
+    except Exception as e:
+        logger.error(f"ROI calculation error: {e}")
+        
+        # Provide fallback results
+        fallback_result = {
+            "status": "✅ Calculated Successfully",
+            "summary": {
+                "your_annual_impact": "$1,530,000",
+                "potential_savings": "$1,254,600",
+                "enterprise_cost": "$625,000",
+                "roi_multiplier": "5.2×",
+                "payback_months": "6.0",
+                "annual_roi_percentage": "420%"
+            }
+        }
+        
+        # Always return a valid chart
+        viz_engine = get_components()["EnhancedVisualizationEngine"]
+        fallback_chart = viz_engine.create_executive_dashboard({"roi_multiplier": 5.2})
+        
+        return fallback_result, fallback_chart
+
 # ===========================================
 # CREATE DEMO INTERFACE
 # ===========================================
 def create_demo_interface():
     """Create demo interface using modular components"""
     
-    import gradio as gr
+    # Get components
+    components = get_components()
+    if "gr" not in components:
+        logger.error("❌ Gradio not available - cannot create interface")
+        raise ImportError("Gradio is required but not available")
+    
+    gr = components["gr"]
     
     # Get CSS styles
-    css_styles = get_components()["get_styles"]()
+    css_styles = components["get_styles"]()
     
     with gr.Blocks(
         title=f"🚀 ARF Investor Demo v3.8.0 - TRUE ARF v3.3.7",
@@ -1094,10 +1261,10 @@ def create_demo_interface():
     ) as demo:
         
         # Header - Updated to show true ARF version
-        header_html = get_components()["create_header"]("3.3.7", settings.use_true_arf)
+        header_html = components["create_header"]("3.3.7", settings.use_true_arf)
         
         # Status bar
-        status_html = get_components()["create_status_bar"]()
+        status_html = components["create_status_bar"]()
         
         # ============ 5 TABS ============
         with gr.Tabs(elem_classes="tab-nav"):
@@ -1109,31 +1276,31 @@ def create_demo_interface():
                  oss_section, enterprise_section, oss_btn, enterprise_btn, 
                  approval_toggle, mcp_mode, timeline_viz,
                  detection_time, mttr, auto_heal, savings,
-                 oss_results_display, enterprise_results_display, approval_display, demo_btn) = get_components()["create_tab1_incident_demo"]()
+                 oss_results_display, enterprise_results_display, approval_display, demo_btn) = components["create_tab1_incident_demo"]()
             
             # TAB 2: Business ROI
             with gr.TabItem("💰 Business Impact & ROI", id="tab2"):
                 (dashboard_output, roi_scenario_dropdown, monthly_slider, team_slider,
-                 calculate_btn, roi_output, roi_chart) = get_components()["create_tab2_business_roi"](get_components()["INCIDENT_SCENARIOS"])
+                 calculate_btn, roi_output, roi_chart) = components["create_tab2_business_roi"](components["INCIDENT_SCENARIOS"])
             
             # TAB 3: Enterprise Features
             with gr.TabItem("🏢 Enterprise Features", id="tab3"):
                 (license_display, validate_btn, trial_btn, upgrade_btn,
-                 mcp_mode_tab3, mcp_mode_info, features_table, integrations_table) = get_components()["create_tab3_enterprise_features"]()
+                 mcp_mode_tab3, mcp_mode_info, features_table, integrations_table) = components["create_tab3_enterprise_features"]()
             
             # TAB 4: Audit Trail
             with gr.TabItem("📜 Audit Trail & History", id="tab4"):
                 (refresh_btn, clear_btn, export_btn, execution_table,
-                 incident_table, export_text) = get_components()["create_tab4_audit_trail"]()
+                 incident_table, export_text) = components["create_tab4_audit_trail"]()
             
             # TAB 5: Learning Engine
             with gr.TabItem("🧠 Learning Engine", id="tab5"):
                 (learning_graph, graph_type, show_labels, search_query, search_btn,
                  clear_btn_search, search_results, stats_display, patterns_display,
-                 performance_display) = get_components()["create_tab5_learning_engine"]()
+                 performance_display) = components["create_tab5_learning_engine"]()
         
         # Footer
-        footer_html = get_components()["create_footer"]()
+        footer_html = components["create_footer"]()
         
         # ============ EVENT HANDLERS ============
         
@@ -1174,13 +1341,13 @@ def create_demo_interface():
             # Step 3: Execute Enterprise (simulation)
             await asyncio.sleep(1)
             
-            scenario = get_components()["INCIDENT_SCENARIOS"].get(scenario_name, {})
+            scenario = components["INCIDENT_SCENARIOS"].get(scenario_name, {})
             impact = scenario.get("business_impact", {})
             revenue_loss = impact.get("revenue_loss_per_hour", get_scenario_impact(scenario_name))
             savings = int(revenue_loss * 0.85)
             
             # Get orchestrator for execution simulation
-            orchestrator = get_components()["DemoOrchestrator"]()
+            orchestrator = components["DemoOrchestrator"]()
             execution_result = await orchestrator.execute_healing(scenario_name, "autonomous")
             
             enterprise_results = {
@@ -1251,58 +1418,6 @@ def create_demo_interface():
         )
         
         # ============ TAB 2 HANDLERS ============
-        
-        def calculate_roi(scenario_name, monthly_incidents, team_size):
-            """Calculate ROI"""
-            try:
-                logger.info(f"Calculating ROI for {scenario_name}")
-                
-                # Validate inputs
-                monthly_incidents = int(monthly_incidents) if monthly_incidents else 15
-                team_size = int(team_size) if team_size else 5
-                
-                # Get scenario-specific impact
-                avg_impact = get_scenario_impact(scenario_name)
-                
-                # Calculate ROI
-                roi_calculator = get_components()["EnhancedROICalculator"]
-                roi_result = roi_calculator.calculate_comprehensive_roi(
-                    monthly_incidents=monthly_incidents,
-                    avg_impact=float(avg_impact),
-                    team_size=team_size
-                )
-                
-                # Extract ROI multiplier for visualization
-                roi_multiplier = extract_roi_multiplier(roi_result)
-                
-                # Create visualization
-                viz_engine = get_components()["EnhancedVisualizationEngine"]
-                chart = viz_engine.create_executive_dashboard({"roi_multiplier": roi_multiplier})
-                
-                return roi_result, chart
-                
-            except Exception as e:
-                logger.error(f"ROI calculation error: {e}")
-                
-                # Provide fallback results
-                fallback_result = {
-                    "status": "✅ Calculated Successfully",
-                    "summary": {
-                        "your_annual_impact": "$1,530,000",
-                        "potential_savings": "$1,254,600",
-                        "enterprise_cost": "$625,000",
-                        "roi_multiplier": "5.2×",
-                        "payback_months": "6.0",
-                        "annual_roi_percentage": "420%"
-                    }
-                }
-                
-                # Always return a valid chart
-                viz_engine = get_components()["EnhancedVisualizationEngine"]
-                fallback_chart = viz_engine.create_executive_dashboard({"roi_multiplier": 5.2})
-                
-                return fallback_result, fallback_chart
-        
         calculate_btn.click(
             fn=calculate_roi,
             inputs=[roi_scenario_dropdown, monthly_slider, team_slider],
@@ -1310,7 +1425,6 @@ def create_demo_interface():
         )
         
         # ============ TAB 3 HANDLERS ============
-        
         def validate_license():
             installation = get_installation_status()
             return {
@@ -1391,7 +1505,6 @@ def create_demo_interface():
         )
         
         # ============ TAB 4 HANDLERS ============
-        
         def refresh_audit_trail():
             return get_audit_manager().get_execution_table(), get_audit_manager().get_incident_table()
         
@@ -1478,8 +1591,8 @@ def main():
     # Check installation status first
     installation = get_installation_status()
     print(f"📦 Package Status:")
-    print(f"  • ARF OSS: {'✅ v' + installation['oss_version'] if installation['oss_installed'] else '⚠️ Not installed'}")
-    print(f"  • Enterprise: {'✅ v' + installation['enterprise_version'] if installation['enterprise_installed'] else '⚠️ Not installed'}")
+    print(f"  • ARF OSS: {'✅ v' + str(installation['oss_version']) if installation['oss_installed'] else '⚠️ Not installed'}")
+    print(f"  • Enterprise: {'✅ v' + str(installation['enterprise_version']) if installation['enterprise_installed'] else '⚠️ Not installed'}")
     print(f"  • Execution Allowed: {'✅ Yes' if installation['execution_allowed'] else '❌ No (OSS only)'}")
     
     print(f"📊 Mode: {settings.arf_mode.upper()}")
@@ -1494,18 +1607,21 @@ def main():
             print(f"  • {rec}")
     print("=" * 70)
     
-    import gradio as gr
-    
     # Create and launch demo
-    demo = create_demo_interface()
-    
-    # Hugging Face Spaces compatible launch
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True  # Show errors in UI
-    )
+    try:
+        demo = create_demo_interface()
+        
+        # Hugging Face Spaces compatible launch
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True  # Show errors in UI
+        )
+    except Exception as e:
+        logger.error(f"❌ Failed to launch demo: {e}")
+        logger.error(traceback.format_exc())
+        raise
 
 
 # Hugging Face Spaces entry point