Update app.py

app.py

@@ -3,6 +3,7 @@
 MODULAR VERSION - Properly integrated with all components
 ULTIMATE FIXED VERSION with all critical issues resolved
 NOW WITH TRUE ARF v3.3.7 INTEGRATION AND DYNAMIC SCENARIO METRICS
+FIXED VERSION: Added scenario_config_path and fixed get_styles
 """
 
 import logging
@@ -32,6 +33,108 @@ 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
 # ===========================================
@@ -67,38 +170,16 @@ class AsyncRunner:
         return wrapper
 
 # ===========================================
-# SIMPLE SETTINGS - AVOID PYDANTIC ISSUES
+# SIMPLE SETTINGS
 # ===========================================
 class Settings:
-    """Simple settings class that avoids pydantic issues"""
+    """Simple settings class"""
     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()
 
@@ -107,50 +188,43 @@ settings = Settings()
 # ===========================================
 def create_empty_plot(title: str):
     """Create an empty placeholder plot"""
-    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
+    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
 
 def create_empty_dashboard():
     """Create empty dashboard"""
-    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
+    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
 
 def get_inactive_agent_html(agent_name: str, description: str):
     """Get HTML for inactive agent state"""
@@ -175,157 +249,7 @@ def get_inactive_agent_html(agent_name: str, description: str):
     """
 
 # ===========================================
-# 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
+# IMPORT MODULAR COMPONENTS - FIXED VERSION WITH ERROR HANDLING
 # ===========================================
 def import_components() -> Dict[str, Any]:
     """Safely import all components with proper error handling - FIXED"""
@@ -333,7 +257,6 @@ def import_components() -> Dict[str, Any]:
         "all_available": False,
         "error": None,
         "get_styles": lambda: "",  # Default empty styles
-        "INCIDENT_SCENARIOS": FALLBACK_SCENARIOS  # Default scenarios
     }
     
     try:
@@ -358,8 +281,22 @@ def import_components() -> Dict[str, Any]:
             # Use empty styles as fallback
             components["get_styles"] = lambda: ""
         
-        # Import UI components
+        # Import UI components with better error handling
         try:
+            # First try to create a scenarios fallback
+            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}
+                }
+            }
+            
+            # Now try to import UI components
             from ui.components import (
                 create_header, create_status_bar, create_tab1_incident_demo,
                 create_tab2_business_roi, create_tab3_enterprise_features,
@@ -391,14 +328,25 @@ def import_components() -> Dict[str, Any]:
                 "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 to import scenarios from demo module (fallback)
         try:
             from demo.scenarios import INCIDENT_SCENARIOS
             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}, using fallback scenarios")
-            components["INCIDENT_SCENARIOS"] = FALLBACK_SCENARIOS
+            logger.warning(f"⚠️ Demo scenarios not available: {e}")
+            # Create minimal fallback scenarios
+            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}
+                }
+            }
         
         # Try to import TrueARF337Orchestrator
         try:
@@ -433,7 +381,6 @@ def import_components() -> Dict[str, Any]:
         
         # Try to import ROI calculator (but don't let it crash)
         try:
-            # First, try to import without triggering settings
             import importlib.util
             spec = importlib.util.find_spec("core.calculators")
             if spec is not None:
@@ -503,6 +450,16 @@ def import_components() -> Dict[str, Any]:
                 components["gr"] = gr
             except:
                 pass
+        
+        # Ensure we have scenarios
+        if "INCIDENT_SCENARIOS" not in components:
+            components["INCIDENT_SCENARIOS"] = {
+                "Cache Miss Storm": {
+                    "component": "Redis Cache Cluster",
+                    "severity": "HIGH",
+                    "business_impact": {"revenue_loss_per_hour": 8500}
+                }
+            }
     
     return components
 
@@ -632,10 +589,7 @@ def create_telemetry_plot(scenario_name: str):
     """Create a telemetry visualization for the selected scenario"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        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
+        return viz_engine.create_telemetry_plot(scenario_name, anomaly_detected=True)
     except Exception as e:
         logger.error(f"Failed to create telemetry plot: {e}")
         return create_empty_plot(f"Telemetry: {scenario_name}")
@@ -644,10 +598,7 @@ def create_impact_plot(scenario_name: str):
     """Create a business impact visualization"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        plot = viz_engine.create_impact_gauge(scenario_name)
-        if plot is None:
-            return create_empty_plot(f"Impact: {scenario_name}")
-        return plot
+        return viz_engine.create_impact_gauge(scenario_name)
     except Exception as e:
         logger.error(f"Failed to create impact plot: {e}")
         return create_empty_plot(f"Impact: {scenario_name}")
@@ -656,10 +607,7 @@ def create_timeline_plot(scenario_name: str):
     """Create an incident timeline visualization"""
     try:
         viz_engine = get_components()["EnhancedVisualizationEngine"]
-        plot = viz_engine.create_timeline_comparison()
-        if plot is None:
-            return create_empty_plot("Timeline Comparison")
-        return plot
+        return viz_engine.create_timeline_comparison()
     except Exception as e:
         logger.error(f"Failed to create timeline plot: {e}")
         return create_empty_plot("Timeline Comparison")
@@ -737,9 +685,8 @@ async def run_true_arf_analysis(scenario_name: str):
         installation = get_installation_status()
         real_arf_available = installation["oss_installed"]
         
-        # Use orchestrator for analysis
-        orchestrator_class = get_components()["DemoOrchestrator"]
-        orchestrator = orchestrator_class()
+        # Use TrueARF337Orchestrator if available
+        orchestrator = get_components()["DemoOrchestrator"]()
         analysis = await orchestrator.analyze_incident(scenario_name, scenario)
         
         # Check for errors
@@ -754,6 +701,8 @@ 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)
         
@@ -876,7 +825,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}")
+        logger.info(f"Analysis completed successfully for {scenario_name} (True ARF: {real_arf_version})")
         return (
             detection_html, recall_html, decision_html,
             oss_results, incident_table_data
@@ -951,10 +900,9 @@ 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"""
-    components = get_components()
-    gr = components["gr"]
+    import gradio as gr
     
-    scenario = components["INCIDENT_SCENARIOS"].get(scenario_name, {})
+    scenario = get_components()["INCIDENT_SCENARIOS"].get(scenario_name, {})
     
     # Determine mode
     mode = "Approval" if approval_required else "Autonomous"
@@ -1002,7 +950,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 = components["DemoOrchestrator"]()
+    orchestrator = get_components()["DemoOrchestrator"]()
     
     # Create approval display
     if approval_required:
@@ -1185,79 +1133,26 @@ 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
+# CREATE DEMO INTERFACE - FIXED FOR GRADIO 6.0
 # ===========================================
 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 = components["get_styles"]()
     
+    # Store CSS for later use in launch()
+    global _demo_css
+    _demo_css = css_styles
+    
+    # Create interface without css parameter (will be added in launch)
     with gr.Blocks(
-        title=f"🚀 ARF Investor Demo v3.8.0 - TRUE ARF v3.3.7",
-        css=css_styles
+        title=f"🚀 ARF Investor Demo v3.8.0 - TRUE ARF v3.3.7"
     ) as demo:
         
         # Header - Updated to show true ARF version
@@ -1418,6 +1313,58 @@ 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 = 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 = 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 = 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],
@@ -1425,6 +1372,7 @@ def create_demo_interface():
         )
         
         # ============ TAB 3 HANDLERS ============
+        
         def validate_license():
             installation = get_installation_status()
             return {
@@ -1505,6 +1453,7 @@ def create_demo_interface():
         )
         
         # ============ TAB 4 HANDLERS ============
+        
         def refresh_audit_trail():
             return get_audit_manager().get_execution_table(), get_audit_manager().get_incident_table()
         
@@ -1579,6 +1528,8 @@ def create_demo_interface():
     
     return demo
 
+# Global variable for CSS
+_demo_css = ""
 
 # ===========================================
 # MAIN EXECUTION - HUGGING FACE COMPATIBLE
@@ -1591,8 +1542,8 @@ def main():
     # Check installation status first
     installation = get_installation_status()
     print(f"📦 Package Status:")
-    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"  • 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"  • Execution Allowed: {'✅ Yes' if installation['execution_allowed'] else '❌ No (OSS only)'}")
     
     print(f"📊 Mode: {settings.arf_mode.upper()}")
@@ -1607,21 +1558,19 @@ def main():
             print(f"  • {rec}")
     print("=" * 70)
     
+    import gradio as gr
+    
     # Create and launch demo
-    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
+    demo = create_demo_interface()
+    
+    # Hugging Face Spaces compatible launch WITH CSS for Gradio 6.0
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,  # Show errors in UI
+        css=_demo_css  # CSS parameter moved here for Gradio 6.0
+    )
 
 
 # Hugging Face Spaces entry point