Update app.py

app.py

@@ -30,6 +30,16 @@ logger = logging.getLogger(__name__)
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent))
 
+# ===========================================
+# FIX FOR ASYNC EVENT LOOP ISSUES
+# ===========================================
+try:
+    import nest_asyncio
+    nest_asyncio.apply()
+    logger.info("✅ Applied nest_asyncio for async event loop compatibility")
+except ImportError:
+    logger.warning("⚠️ nest_asyncio not available, async operations may have issues")
+
 # ===========================================
 # IMPORT UTILITY CLASSES FIRST
 # ===========================================
@@ -207,10 +217,10 @@ class AsyncRunner:
         return wrapper
 
 # ===========================================
-# SIMPLE SETTINGS
+# SIMPLE SETTINGS - FIXED: Added missing attribute
 # ===========================================
 class Settings:
-    """Simple settings class"""
+    """Simple settings class - FIXED: Added default_savings_rate"""
     def __init__(self):
         self.arf_mode = "demo"
         self.use_true_arf = True
@@ -220,6 +230,7 @@ class Settings:
         self.show_boundaries = True
         self.architectural_honesty = True
         self.engineer_annual_cost = 200000
+        self.default_savings_rate = 0.25  # FIXED: Added missing attribute
 
 settings = Settings()
 
@@ -755,10 +766,10 @@ def get_inactive_agent_html(agent_name: str, description: str, is_real_arf: bool
     """
 
 # ===========================================
-# IMPORT MODULAR COMPONENTS
+# IMPORT MODULAR COMPONENTS - FIXED: Added MockEnhancedROICalculator
 # ===========================================
 def import_components() -> Dict[str, Any]:
-    """Safely import all components with proper error handling"""
+    """Safely import all components with proper error handling - FIXED: Added mock ROI calculator"""
     components = {
         "all_available": False,
         "error": None,
@@ -835,27 +846,79 @@ def import_components() -> Dict[str, Any]:
                         }
                 components["DemoOrchestrator"] = MockOrchestrator
         
-        # Try to import ROI calculator
+        # FIXED: EnhancedROICalculator with proper mock fallback
         try:
             from core.calculators import EnhancedROICalculator
             components["EnhancedROICalculator"] = EnhancedROICalculator()
+            logger.info("✅ Real EnhancedROICalculator loaded")
         except ImportError:
-            class MockCalculator:
-                def calculate_comprehensive_roi(self, **kwargs):
+            # Create comprehensive mock ROI calculator
+            class MockEnhancedROICalculator:
+                """Mock ROI calculator for demo purposes - FIXED to prevent KeyError"""
+                
+                def calculate_comprehensive_roi(self, scenario_name=None, monthly_incidents=15, team_size=5, **kwargs):
+                    """Calculate comprehensive ROI metrics with realistic mock data"""
+                    from datetime import datetime
+                    
+                    # Mock ROI calculation with realistic values
+                    impact_map = {
+                        "Cache Miss Storm": 8500,
+                        "Database Connection Pool Exhaustion": 4200,
+                        "Kubernetes Memory Leak": 5500,
+                        "API Rate Limit Storm": 3800,
+                        "Network Partition": 12000,
+                        "Storage I/O Saturation": 6800
+                    }
+                    
+                    impact_per_incident = impact_map.get(scenario_name or "Cache Miss Storm", 5000)
+                    annual_impact = impact_per_incident * monthly_incidents * 12
+                    potential_savings = int(annual_impact * 0.82)
+                    enterprise_cost = 625000
+                    roi_multiplier = round(potential_savings / enterprise_cost, 1)
+                    payback_months = round((enterprise_cost / (potential_savings / 12)), 1)
+                    
                     return {
                         "status": "✅ Calculated Successfully",
+                        "scenario": scenario_name or "Cache Miss Storm",
+                        "timestamp": datetime.now().isoformat(),
+                        "calculator": "MockEnhancedROICalculator",
                         "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%",
+                            "your_annual_impact": f"${annual_impact:,}",
+                            "potential_savings": f"${potential_savings:,}",
+                            "enterprise_cost": f"${enterprise_cost:,}",
+                            "roi_multiplier": f"{roi_multiplier}×",
+                            "payback_months": f"{payback_months}",
+                            "annual_roi_percentage": f"{int((potential_savings - enterprise_cost) / enterprise_cost * 100)}%",
                             "boundary_context": "Based on OSS analysis + simulated Enterprise execution"
                         },
-                        "boundary_note": "ROI calculation includes OSS advisory value and simulated Enterprise execution benefits"
+                        "breakdown": {
+                            "direct_cost_savings": f"${int(potential_savings * 0.7):,}",
+                            "productivity_gains": f"${int(potential_savings * 0.2):,}",
+                            "risk_reduction": f"${int(potential_savings * 0.1):,}"
+                        },
+                        "annual_projection": {
+                            "incidents_prevented": monthly_incidents * 12,
+                            "annual_savings": f"${potential_savings:,}",
+                            "roi": f"{roi_multiplier}×"
+                        },
+                        "notes": [
+                            "📊 ROI calculation using mock data",
+                            "💡 Real enterprise ROI includes additional factors",
+                            "🔒 Full ROI requires Enterprise edition",
+                            f"📈 Based on {monthly_incidents} incidents/month"
+                        ]
                     }
-            components["EnhancedROICalculator"] = MockCalculator()
+                
+                def get_roi_visualization_data(self):
+                    """Get data for ROI visualization"""
+                    return {
+                        "labels": ["Direct Savings", "Productivity", "Risk Reduction", "Upsell"],
+                        "values": [65, 20, 10, 5],
+                        "colors": ["#10b981", "#3b82f6", "#8b5cf6", "#f59e0b"]
+                    }
+            
+            components["EnhancedROICalculator"] = MockEnhancedROICalculator()
+            logger.info("✅ Mock EnhancedROICalculator created (preventing KeyError)")
         
         # Try to import visualization engine
         try:
@@ -896,6 +959,16 @@ def import_components() -> Dict[str, Any]:
                     "boundary_note": "OSS analysis only - execution requires Enterprise"
                 }
             }
+        
+        # Ensure EnhancedROICalculator exists
+        if "EnhancedROICalculator" not in components:
+            class MinimalROICalculator:
+                def calculate_comprehensive_roi(self, **kwargs):
+                    return {
+                        "status": "✅ Minimal ROI Calculation",
+                        "summary": {"roi_multiplier": "5.2×"}
+                    }
+            components["EnhancedROICalculator"] = MinimalROICalculator()
     
     return components
 
@@ -910,10 +983,10 @@ def get_components() -> Dict[str, Any]:
     return _components
 
 # ===========================================
-# AUDIT TRAIL MANAGER
+# AUDIT TRAIL MANAGER - FIXED: Returns DataFrames instead of HTML
 # ===========================================
 class AuditTrailManager:
-    """Enhanced audit trail manager with boundary tracking"""
+    """Enhanced audit trail manager with boundary tracking - FIXED to return DataFrames"""
     
     def __init__(self):
         self.executions = []
@@ -961,8 +1034,114 @@ class AuditTrailManager:
         logger.info(f"📝 Incident analysis recorded: {scenario_name}")
         return record
     
-    def get_execution_table(self):
-        """Get executions as HTML table"""
+    def get_execution_dataframe(self) -> pd.DataFrame:
+        """
+        FIXED: Returns pandas DataFrame for Gradio DataFrame component
+        """
+        try:
+            if not self.executions:
+                # Return empty DataFrame with correct columns
+                return pd.DataFrame(columns=[
+                    "Execution ID", "Scenario", "Status", "Mode", 
+                    "Start Time", "End Time", "Duration", "Boundary"
+                ])
+            
+            # Build DataFrame from executions
+            data = []
+            for i, execution in enumerate(self.executions):
+                # Extract execution ID from result or generate one
+                exec_id = execution.get("result", {}).get("execution_id", f"exec_{i}")
+                status = "Success" if "success" in str(execution.get("result", {})).lower() else "Failed"
+                mode = execution.get("mode", "unknown")
+                scenario = execution.get("scenario", "Unknown")
+                timestamp = execution.get("timestamp", "")
+                boundary = execution.get("boundary_context", "Unknown")
+                
+                # Extract end time from telemetry if available
+                end_time = execution.get("result", {}).get("telemetry", {}).get("end_time", "")
+                duration = "12m"  # Mock duration
+                
+                data.append({
+                    "Execution ID": exec_id,
+                    "Scenario": scenario,
+                    "Status": status,
+                    "Mode": mode,
+                    "Start Time": timestamp[:19] if timestamp else "",  # Format: YYYY-MM-DD HH:MM:SS
+                    "End Time": end_time[:19] if end_time else "",
+                    "Duration": duration,
+                    "Boundary": boundary
+                })
+            
+            df = pd.DataFrame(data)
+            
+            # Sort by time (newest first)
+            if not df.empty and "Start Time" in df.columns:
+                df = df.sort_values("Start Time", ascending=False)
+            
+            return df
+            
+        except Exception as e:
+            logger.error(f"Error creating execution DataFrame: {e}")
+            # Return empty DataFrame as fallback
+            return pd.DataFrame(columns=[
+                "Error", "Message"
+            ]).from_records([{"Error": "DataFrame Error", "Message": str(e)}])
+    
+    def get_incident_dataframe(self) -> pd.DataFrame:
+        """
+        FIXED: Returns pandas DataFrame for Gradio DataFrame component
+        """
+        try:
+            if not self.incidents:
+                # Return empty DataFrame with correct columns
+                return pd.DataFrame(columns=[
+                    "Scenario", "Status", "Boundary", "Time", 
+                    "Confidence", "Action", "Target"
+                ])
+            
+            # Build DataFrame from incidents
+            data = []
+            for i, incident in enumerate(self.incidents):
+                scenario = incident.get("scenario", "Unknown")
+                analysis = incident.get("analysis", {})
+                status = analysis.get("status", "analyzed").capitalize()
+                boundary = incident.get("boundary_context", "OSS analysis")
+                timestamp = incident.get("timestamp", "")
+                time_display = timestamp[11:19] if len(timestamp) > 11 else ""
+                
+                # Extract analysis details
+                healing_intent = analysis.get("oss_analysis", {}).get("analysis", {}).get("decision", {})
+                confidence = healing_intent.get("confidence", 0.85)
+                action = healing_intent.get("action", "Analysis")
+                target = healing_intent.get("target", "system")
+                
+                data.append({
+                    "Scenario": scenario,
+                    "Status": status,
+                    "Boundary": boundary,
+                    "Time": time_display,
+                    "Confidence": f"{confidence * 100:.1f}%",
+                    "Action": action,
+                    "Target": target
+                })
+            
+            df = pd.DataFrame(data)
+            
+            # Sort by time (newest first)
+            if not df.empty and "Time" in df.columns:
+                df = df.sort_values("Time", ascending=False)
+            
+            return df
+            
+        except Exception as e:
+            logger.error(f"Error creating incident DataFrame: {e}")
+            # Return empty DataFrame as fallback
+            return pd.DataFrame(columns=[
+                "Error", "Message"
+            ]).from_records([{"Error": "DataFrame Error", "Message": str(e)}])
+    
+    def get_execution_table_html(self):
+        """Legacy HTML method for backward compatibility"""
         if not self.executions:
             return """
             <div style="text-align: center; padding: 30px; color: #64748b;">
@@ -1016,8 +1195,8 @@ class AuditTrailManager:
         </div>
         """
     
-    def get_incident_table(self):
-        """Get incidents as HTML table"""
+    def get_incident_table_html(self):
+        """Legacy HTML method for backward compatibility"""
         if not self.incidents:
             return """
             <div style="text-align: center; padding: 30px; color: #64748b;">
@@ -1223,7 +1402,7 @@ def update_scenario_display(scenario_name: str) -> tuple:
     return scenario_card_html, telemetry_fig, impact_fig, timeline_fig
 
 # ===========================================
-# SURGICAL FIX 5: run_true_arf_analysis()
+# SURGICAL FIX 5: run_true_arf_analysis() - FIXED to return DataFrames
 # ===========================================
 @AsyncRunner.async_to_sync
 async def run_true_arf_analysis(scenario_name: str) -> tuple:
@@ -1233,7 +1412,7 @@ async def run_true_arf_analysis(scenario_name: str) -> tuple:
     2. recall_html (HTML string)
     3. decision_html (HTML string)
     4. oss_results_dict (Python dict for JSON display)
-    5. incident_table_html (HTML string)
+    5. incident_df (DataFrame for Gradio DataFrame component)
     """
     
     components = get_components()
@@ -1383,10 +1562,10 @@ async def run_true_arf_analysis(scenario_name: str) -> tuple:
                 "boundary_note": f"Mock analysis - {boundary_text}"
             }
         
-        # Incident Table HTML
-        incident_table_html = get_audit_manager().get_incident_table()
+        # Incident DataFrame (FIXED: Returns DataFrame instead of HTML)
+        incident_df = get_audit_manager().get_incident_dataframe()
         
-        return detection_html, recall_html, decision_html, oss_results_dict, incident_table_html
+        return detection_html, recall_html, decision_html, oss_results_dict, incident_df
         
     except Exception as e:
         logger.error(f"True ARF analysis failed: {e}")
@@ -1420,15 +1599,20 @@ async def run_true_arf_analysis(scenario_name: str) -> tuple:
             "recommendation": "Check ARF installation"
         }
         
-        return error_html, error_html, error_html, error_dict, "Error loading incident table"
+        # Return empty DataFrame on error
+        error_df = pd.DataFrame(columns=["Error", "Message"]).from_records([
+            {"Error": "Analysis Failed", "Message": str(e)}
+        ])
+        
+        return error_html, error_html, error_html, error_dict, error_df
 
 # ===========================================
-# FIXED EXECUTION FUNCTION
+# FIXED EXECUTION FUNCTION - Returns DataFrames
 # ===========================================
 def execute_enterprise_healing(scenario_name, approval_required, mcp_mode_value):
     """
     MINIMAL FIX: Returns proper data types matching UI expectations
-    Keeping original return structure but fixing types
+    FIXED: Returns DataFrame instead of HTML for execution table
     """
     import gradio as gr
     
@@ -1535,10 +1719,10 @@ def execute_enterprise_healing(scenario_name, approval_required, mcp_mode_value)
             ]
         }
     
-    # Get execution table HTML
-    execution_table = get_audit_manager().get_execution_table()
+    # Get execution DataFrame (FIXED: Returns DataFrame instead of HTML)
+    execution_df = get_audit_manager().get_execution_dataframe()
     
-    return approval_display, enterprise_results, execution_table
+    return approval_display, enterprise_results, execution_df
 
 # ===========================================
 # FIXED ROI FUNCTION
@@ -1608,7 +1792,7 @@ def calculate_roi(scenario_name, monthly_incidents, team_size):
     return roi_result, fig
 
 # ===========================================
-# CREATE DEMO INTERFACE - UNCHANGED
+# CREATE DEMO INTERFACE - UNCHANGED except for DataFrame fixes
 # ===========================================
 def create_demo_interface():
     """Create demo interface using modular components with boundary awareness"""
@@ -1687,7 +1871,7 @@ def create_demo_interface():
             outputs=[scenario_card, telemetry_viz, impact_viz, timeline_viz]
         )
         
-        # Run OSS Analysis - FIXED: Now receives 5 values
+        # Run OSS Analysis - FIXED: Now returns DataFrame for incident_table
         oss_btn.click(
             fn=run_true_arf_analysis,
             inputs=[scenario_dropdown],
@@ -1697,7 +1881,7 @@ def create_demo_interface():
             ]
         )
         
-        # Execute Enterprise Healing
+        # Execute Enterprise Healing - FIXED: Now returns DataFrame for execution_table
         enterprise_btn.click(
             fn=execute_enterprise_healing,
             inputs=[scenario_dropdown, approval_toggle, mcp_mode],
@@ -1892,9 +2076,9 @@ def create_demo_interface():
             # Update the enterprise_results_display to include demo completion info
             enterprise_results["demo_completion_message"] = demo_message
             
-            # Get updated tables
-            incident_table_data = get_audit_manager().get_incident_table()
-            execution_table_data = get_audit_manager().get_execution_table()
+            # Get updated DataFrames (FIXED: Returns DataFrames)
+            incident_df = get_audit_manager().get_incident_dataframe()
+            execution_df = get_audit_manager().get_execution_dataframe()
             
             # Combine all results
             return (
@@ -1903,8 +2087,8 @@ def create_demo_interface():
                 oss_result[3],    # 1 output: oss_results_display
                 enterprise_results,  # 1 output: enterprise_results_display  
                 demo_message,  # 1 output: approval_display
-                incident_table_data,  # 1 output: incident_table
-                execution_table_data  # 1 output: execution_table
+                incident_df,  # 1 output: incident_table (DataFrame)
+                execution_df  # 1 output: execution_table (DataFrame)
             )
         
         # FIXED: demo_btn.click with correct output count
@@ -1929,10 +2113,10 @@ def create_demo_interface():
             outputs=[roi_output, roi_chart]
         )
         
-        # Update ROI scenario
+        # Update ROI scenario - FIXED: Use the EnhancedROICalculator
         roi_scenario_dropdown.change(
-            fn=lambda x: get_components()["EnhancedROICalculator"]().calculate_comprehensive_roi(),
-            inputs=[],
+            fn=lambda x: get_components()["EnhancedROICalculator"].calculate_comprehensive_roi(scenario_name=x),
+            inputs=[roi_scenario_dropdown],
             outputs=[roi_output]
         )
         
@@ -1949,18 +2133,21 @@ def create_demo_interface():
             outputs=[roi_chart]
         )
         
-        # Audit Trail Functions
+        # Audit Trail Functions - FIXED: Returns DataFrames
         def refresh_audit_trail():
-            """Refresh audit trail tables"""
+            """Refresh audit trail tables - FIXED to return DataFrames"""
             return (
-                get_audit_manager().get_execution_table(),
-                get_audit_manager().get_incident_table()
+                get_audit_manager().get_execution_dataframe(),  # DataFrame
+                get_audit_manager().get_incident_dataframe()    # DataFrame
             )
         
         def clear_audit_trail():
-            """Clear audit trail"""
+            """Clear audit trail - FIXED to return empty DataFrames"""
             get_audit_manager().clear()
-            return [], []
+            # Return empty DataFrames with correct columns
+            exec_df = pd.DataFrame(columns=["Execution ID", "Scenario", "Status", "Mode", "Start Time"])
+            incident_df = pd.DataFrame(columns=["Scenario", "Status", "Boundary", "Time"])
+            return exec_df, incident_df
         
         def export_audit_trail():
             """Export audit trail as JSON"""