Update app.py

app.py

@@ -1,17 +1,22 @@
 """
-🚀 ARF Ultimate Investor Demo v3.6.0 - PRODUCTION VERSION
-Integrated with actual ARF OSS package v3.3.6
-From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability
+🚀 ARF Investor Demo - COMPLETE STANDALONE VERSION
+No module dependencies - Everything in one file
+Works on Hugging Face Spaces
 """
 
 import logging
-import uuid
+import datetime
 import random
-from datetime import datetime
-from typing import Dict, Any, List, Optional, Tuple
+import uuid
+from typing import Dict, List, Optional, Any
 import gradio as gr
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import numpy as np
+from plotly.subplots import make_subplots
 
-# Import actual ARF OSS components
+# Import ARF OSS if available
 try:
     from agentic_reliability_framework.arf_core.models.healing_intent import (
         HealingIntent,
@@ -26,7 +31,7 @@ except ImportError as e:
     logger = logging.getLogger(__name__)
     logger.warning(f"⚠️ ARF OSS not available: {e}. Running in simulation mode.")
     
-    # Mock classes for demo
+    # Mock classes
     class HealingIntent:
         def __init__(self, **kwargs):
             self.intent_type = kwargs.get("intent_type", "scale_out")
@@ -36,7 +41,7 @@ except ImportError as e:
             return {
                 "intent_type": self.intent_type,
                 "parameters": self.parameters,
-                "created_at": datetime.now().isoformat()
+                "created_at": datetime.datetime.now().isoformat()
             }
     
     def create_scale_out_intent(resource_type: str, scale_factor: float = 2.0):
@@ -50,9 +55,6 @@ except ImportError as e:
         )
     
     class OSSMCPClient:
-        def __init__(self):
-            self.mode = "advisory"
-        
         def analyze_incident(self, metrics: Dict, pattern: str = "") -> Dict:
             return {
                 "status": "analysis_complete",
@@ -62,384 +64,337 @@ except ImportError as e:
                     "Add circuit breakers",
                     "Optimize configuration"
                 ],
-                "confidence": 0.92,
-                "pattern_matched": pattern,
-                "healing_intent": {
-                    "type": "scale_out",
-                    "requires_execution": True
-                }
+                "confidence": 0.92
             }
 
-# Import our enhanced modules
-from core.data_models import (
-    IncidentDatabase, IncidentScenario, OSSAnalysis, 
-    EnterpriseResults, DemoMode
-)
-from core.visualizations import EnhancedVisualizationEngine
-from core.calculators import EnhancedROICalculator
-from demo.orchestrator import DemoOrchestrator
-from ui.components import (
-    create_metric_card,
-    create_business_impact_section,
-    create_approval_workflow,
-    create_roi_comparison_table
-)
-from ui.styles import CUSTOM_CSS, THEME
-
 # Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ===========================================
-# ARF OSS INTEGRATION SERVICE
+# DATA - Everything in one place
 # ===========================================
 
-class ARFOSSService:
-    """Service to integrate with actual ARF OSS package"""
-    
-    def __init__(self):
-        self.oss_client = OSSMCPClient() if ARF_OSS_AVAILABLE else OSSMCPClient()
-        self.healing_intents = {}
-        
-    def analyze_with_arf(self, scenario: IncidentScenario) -> Dict:
-        """Analyze incident using actual ARF OSS"""
-        try:
-            # Convert scenario metrics to ARF format
-            arf_metrics = self._convert_to_arf_metrics(scenario.metrics)
-            
-            # Call actual ARF OSS analysis
-            analysis_result = self.oss_client.analyze_incident(
-                metrics=arf_metrics,
-                pattern=scenario.arf_pattern
-            )
-            
-            # Create healing intent
-            healing_intent = create_scale_out_intent(
-                resource_type=self._get_resource_type(scenario.name),
-                scale_factor=2.0
-            )
-            
-            # Store healing intent for reference
-            intent_id = str(uuid.uuid4())[:8]
-            self.healing_intents[intent_id] = {
-                "intent": healing_intent,
-                "scenario": scenario.name,
-                "timestamp": datetime.now()
-            }
-            
-            # Format response
-            return {
-                "analysis": "✅ ARF OSS Analysis Complete",
-                "recommendations": analysis_result.get("recommendations", [
-                    "Implement ARF recommendations",
-                    "Monitor system metrics",
-                    "Apply configuration changes"
-                ]),
-                "healing_intent": healing_intent.to_dict(),
-                "intent_id": intent_id,
-                "arf_oss_version": "3.3.6",
-                "mode": "advisory_only",
-                "requires_execution": True,
-                "estimated_time": "45-90 minutes",
-                "engineers_needed": "2-3 engineers"
-            }
-            
-        except Exception as e:
-            logger.error(f"ARF analysis error: {e}")
-            return {
-                "analysis": "⚠️ ARF Analysis (Simulation Mode)",
-                "recommendations": [
-                    "Increase cache memory allocation",
-                    "Implement cache warming strategy",
-                    "Optimize key patterns",
-                    "Add circuit breaker"
-                ],
-                "arf_oss_available": ARF_OSS_AVAILABLE,
-                "error": str(e) if not ARF_OSS_AVAILABLE else None
+INCIDENT_SCENARIOS = {
+    "Cache Miss Storm": {
+        "metrics": {
+            "Cache Hit Rate": "18.5% (Critical)",
+            "Database Load": "92% (Overloaded)",
+            "Response Time": "1850ms (Slow)",
+            "Affected Users": "45,000"
+        },
+        "impact": {
+            "Revenue Loss": "$8,500/hour",
+            "Page Load Time": "+300%",
+            "Users Impacted": "45,000"
+        },
+        "oss_analysis": {
+            "status": "✅ ARF OSS Analysis Complete",
+            "recommendations": [
+                "Increase Redis cache memory allocation",
+                "Implement cache warming strategy",
+                "Optimize key patterns (TTL adjustments)",
+                "Add circuit breaker for database fallback"
+            ],
+            "estimated_time": "60+ minutes",
+            "engineers_needed": "2-3 SREs",
+            "manual_effort": "High",
+            "arf_oss": True,
+            "healing_intent_created": True
+        },
+        "enterprise_results": {
+            "actions_completed": [
+                "✅ Auto-scaled Redis: 4GB → 8GB",
+                "✅ Deployed cache warming service",
+                "✅ Optimized 12 key patterns",
+                "✅ Implemented circuit breaker"
+            ],
+            "metrics_improvement": {
+                "Cache Hit Rate": "18.5% → 72%",
+                "Response Time": "1850ms → 450ms",
+                "Database Load": "92% → 45%"
+            },
+            "business_impact": {
+                "Recovery Time": "60 min → 12 min",
+                "Cost Saved": "$7,200",
+                "Users Impacted": "45,000 → 0"
             }
-    
-    def _convert_to_arf_metrics(self, metrics: Dict[str, str]) -> Dict[str, float]:
-        """Convert demo metrics to ARF-compatible format"""
-        arf_metrics = {}
-        for key, value in metrics.items():
-            try:
-                # Extract numeric value from string like "18.5% (Critical)"
-                if isinstance(value, str):
-                    # Get first number in string
-                    import re
-                    numbers = re.findall(r"[-+]?\d*\.\d+|\d+", value)
-                    if numbers:
-                        arf_metrics[key] = float(numbers[0])
-                    else:
-                        arf_metrics[key] = 0.0
-                else:
-                    arf_metrics[key] = float(value)
-            except:
-                arf_metrics[key] = 0.0
-        return arf_metrics
-    
-    def _get_resource_type(self, scenario_name: str) -> str:
-        """Map scenario to resource type"""
-        if "Cache" in scenario_name:
-            return "cache"
-        elif "Database" in scenario_name:
-            return "database"
-        elif "Memory" in scenario_name:
-            return "memory"
-        elif "API" in scenario_name:
-            return "api_gateway"
-        else:
-            return "service"
+        }
+    },
+    "Database Connection Pool Exhaustion": {
+        "metrics": {
+            "Active Connections": "98/100 (Critical)",
+            "API Latency": "2450ms",
+            "Error Rate": "15.2%",
+            "Queue Depth": "1250"
+        },
+        "impact": {
+            "Revenue Loss": "$4,200/hour",
+            "Affected Services": "API Gateway, User Service",
+            "SLA Violation": "Yes"
+        }
+    },
+    "Memory Leak in Production": {
+        "metrics": {
+            "Memory Usage": "96% (Critical)",
+            "GC Pause Time": "4500ms",
+            "Error Rate": "28.5%",
+            "Restart Frequency": "12/hour"
+        },
+        "impact": {
+            "Revenue Loss": "$5,500/hour",
+            "Session Loss": "8,500 users",
+            "Customer Impact": "High"
+        }
+    }
+}
 
 # ===========================================
-# APPLICATION STATE WITH ARF INTEGRATION
+# VISUALIZATION FUNCTIONS
 # ===========================================
 
-class ARFDemoState:
-    """Maintain application state with ARF integration"""
+def create_timeline_visualization():
+    """Create interactive timeline"""
+    fig = go.Figure()
     
-    def __init__(self):
-        self.scenario_db = IncidentDatabase()
-        self.viz_engine = EnhancedVisualizationEngine()
-        self.roi_calculator = EnhancedROICalculator()
-        self.demo_orchestrator = DemoOrchestrator(DemoMode.INVESTOR)
-        self.arf_service = ARFOSSService()
-        
-        self.current_scenario = None
-        self.approval_required = True
-        self.arf_analysis_results = {}
-        
-    def get_scenario(self, name: str) -> Optional[IncidentScenario]:
-        """Get scenario by name"""
-        scenarios = self.scenario_db.get_scenarios()
-        return scenarios.get(name)
+    events = [
+        {"time": "T-5m", "event": "📉 Cache hit rate drops", "type": "problem"},
+        {"time": "T-3m", "event": "🤖 ARF detects pattern", "type": "detection"},
+        {"time": "T-2m", "event": "🧠 Analysis complete", "type": "analysis"},
+        {"time": "T-1m", "event": "⚡ Healing executed", "type": "action"},
+        {"time": "Now", "event": "✅ System recovered", "type": "recovery"}
+    ]
     
-    def get_scenario_names(self) -> List[str]:
-        """Get all scenario names"""
-        scenarios = self.scenario_db.get_scenarios()
-        return list(scenarios.keys())
+    colors = {"problem": "red", "detection": "blue", "analysis": "purple", 
+              "action": "green", "recovery": "lightgreen"}
     
-    def perform_arf_analysis(self, scenario_name: str) -> Dict:
-        """Perform actual ARF OSS analysis"""
-        scenario = self.get_scenario(scenario_name)
-        if not scenario:
-            return {"error": "Scenario not found"}
-        
-        self.current_scenario = scenario
-        analysis_result = self.arf_service.analyze_with_arf(scenario)
-        self.arf_analysis_results[scenario_name] = analysis_result
-        
-        # Format for display
-        return {
-            "status": analysis_result["analysis"],
-            "recommendations": analysis_result["recommendations"],
-            "healing_intent": analysis_result.get("healing_intent", {}),
-            "arf_oss": {
-                "version": analysis_result.get("arf_oss_version", "3.3.6"),
-                "available": ARF_OSS_AVAILABLE,
-                "mode": "advisory_only"
-            },
-            "estimated_impact": analysis_result.get("estimated_time", "45-90 minutes"),
-            "action_required": "Manual implementation required",
-            "team_effort": analysis_result.get("engineers_needed", "2-3 engineers"),
-            "total_cost": self._calculate_oss_cost(scenario)
-        }
+    for event in events:
+        fig.add_trace(go.Scatter(
+            x=[event["time"]],
+            y=[1],
+            mode='markers+text',
+            marker=dict(size=15, color=colors[event["type"]], symbol='circle'),
+            text=[event["event"]],
+            textposition="top center",
+            name=event["type"].capitalize()
+        ))
     
-    def _calculate_oss_cost(self, scenario: IncidentScenario) -> str:
-        """Calculate OSS implementation cost"""
-        impact = scenario.impact
-        if "Revenue Loss" in impact:
-            loss = impact["Revenue Loss"]
-            # Extract hourly rate
-            try:
-                hourly_rate = float(''.join(filter(str.isdigit, loss.split('/')[0])))
-                # Assume 60 minutes resolution for OSS
-                return f"${hourly_rate:,.0f}"
-            except:
-                pass
-        return "$3,000 - $8,000"
+    fig.update_layout(
+        title="<b>Incident Timeline</b>",
+        height=400,
+        showlegend=True,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        yaxis=dict(showticklabels=False, range=[0.5, 1.5])
+    )
+    
+    return fig
+
+def create_business_dashboard():
+    """Create executive dashboard"""
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=('Cost Impact', 'Team Time', 'MTTR Comparison', 'ROI'),
+        vertical_spacing=0.15
+    )
+    
+    # 1. Cost Impact
+    categories = ['Without ARF', 'With ARF Enterprise', 'Savings']
+    values = [2.96, 1.0, 1.96]
+    
+    fig.add_trace(
+        go.Bar(x=categories, y=values, marker_color=['#FF6B6B', '#4ECDC4', '#45B7D1']),
+        row=1, col=1
+    )
+    
+    # 2. Team Time
+    activities = ['Firefighting', 'Innovation', 'Strategic']
+    before = [60, 20, 20]
+    after = [10, 60, 30]
+    
+    fig.add_trace(go.Bar(x=activities, y=before, name='Before', marker_color='#FF6B6B'), row=1, col=2)
+    fig.add_trace(go.Bar(x=activities, y=after, name='After', marker_color='#4ECDC4'), row=1, col=2)
+    
+    # 3. MTTR Comparison
+    mttr_methods = ['Manual', 'Traditional', 'ARF OSS', 'ARF Enterprise']
+    mttr_times = [120, 45, 25, 8]
+    
+    fig.add_trace(
+        go.Bar(x=mttr_methods, y=mttr_times, marker_color=['#FF6B6B', '#FFE66D', '#45B7D1', '#4ECDC4']),
+        row=2, col=1
+    )
+    
+    # 4. ROI Gauge
+    fig.add_trace(
+        go.Indicator(
+            mode="gauge+number",
+            value=5.2,
+            title={'text': "ROI Multiplier"},
+            gauge={
+                'axis': {'range': [0, 10]},
+                'bar': {'color': "#4ECDC4"},
+                'steps': [
+                    {'range': [0, 2], 'color': "lightgray"},
+                    {'range': [2, 4], 'color': "gray"},
+                    {'range': [4, 6], 'color': "lightgreen"},
+                    {'range': [6, 10], 'color': "green"}
+                ]
+            }
+        ),
+        row=2, col=2
+    )
+    
+    fig.update_layout(
+        height=700,
+        showlegend=True,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        title_text="<b>Executive Business Dashboard</b>"
+    )
+    
+    return fig
 
 # ===========================================
-# EVENT HANDLERS WITH ARF INTEGRATION
+# BUSINESS LOGIC
 # ===========================================
 
-class EventHandlers:
-    """Handle all application events with ARF integration"""
+def run_oss_analysis(scenario_name: str):
+    """Run OSS analysis"""
+    scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+    analysis = scenario.get("oss_analysis", {})
     
-    def __init__(self, state: ARFDemoState):
-        self.state = state
+    if not analysis:
+        analysis = {
+            "status": "✅ Analysis Complete",
+            "recommendations": [
+                "Increase resource allocation",
+                "Implement monitoring",
+                "Add circuit breakers",
+                "Optimize configuration"
+            ],
+            "estimated_time": "45-60 minutes",
+            "engineers_needed": "2-3",
+            "manual_effort": "Required",
+            "arf_oss": ARF_OSS_AVAILABLE
+        }
     
-    def handle_scenario_change(self, scenario_name: str, viz_type: str) -> tuple:
-        """Handle scenario change"""
-        scenario = self.state.get_scenario(scenario_name)
-        if not scenario:
-            return {}, {}, self.state.viz_engine.create_interactive_timeline(None)
-        
-        self.state.current_scenario = scenario
-        
-        # Create visualization
-        if viz_type == "Interactive Timeline":
-            viz = self.state.viz_engine.create_interactive_timeline(scenario)
-        else:
-            viz = self.state.viz_engine.create_executive_dashboard()
-        
-        return scenario.metrics, scenario.impact, viz
+    # Add ARF context
+    analysis["arf_context"] = {
+        "oss_available": ARF_OSS_AVAILABLE,
+        "version": "3.3.6",
+        "mode": "advisory_only",
+        "healing_intent": "created" if ARF_OSS_AVAILABLE else "simulated"
+    }
     
-    def handle_oss_analysis(self, scenario_name: str) -> Dict:
-        """Handle OSS analysis using actual ARF"""
-        logger.info(f"Performing ARF OSS analysis for: {scenario_name}")
-        
-        # Use actual ARF OSS package
-        result = self.state.perform_arf_analysis(scenario_name)
-        
-        # Add ARF branding
-        result["arf_oss_edition"] = {
-            "version": "3.3.6",
-            "license": "Apache 2.0",
-            "mode": "advisory_only",
-            "execution": "manual_required",
-            "healing_intent_created": "healing_intent" in result
-        }
-        
-        return result
+    return analysis
+
+def execute_enterprise_healing(scenario_name: str, approval_required: bool):
+    """Execute enterprise healing"""
+    scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+    results = scenario.get("enterprise_results", {})
     
-    def handle_enterprise_execution(self, scenario_name: str, 
-                                   approval_required: bool) -> tuple:
-        """Handle enterprise execution (simulated for demo)"""
-        self.state.approval_required = approval_required
-        
-        scenario = self.state.get_scenario(scenario_name)
-        if not scenario:
-            # Default results
-            results = {
-                "status": "❌ Scenario not found",
-                "actions_completed": [],
-                "metrics_improvement": {},
-                "business_impact": {}
-            }
-        else:
-            # Use enterprise results if available, otherwise simulate
-            if scenario.enterprise_results:
-                results = scenario.enterprise_results.to_dict()
-            else:
-                results = self._simulate_enterprise_execution(scenario)
-        
-        # Update status based on approval
-        if approval_required:
-            results["status"] = "✅ Approved and Executed"
-            results["approval_workflow"] = {
-                "required": True,
-                "approved_by": "demo_user",
-                "timestamp": datetime.now().isoformat()
-            }
-        else:
-            results["status"] = "✅ Auto-Executed"
-            results["approval_workflow"] = {
-                "required": False,
-                "mode": "autonomous",
-                "safety_guardrails": "active"
+    if not results:
+        results = {
+            "status": "✅ Auto-Executed" if not approval_required else "✅ Approved and Executed",
+            "actions_completed": [
+                "✅ Auto-scaled resources",
+                "✅ Implemented optimization",
+                "✅ Deployed monitoring",
+                "✅ Validated recovery"
+            ],
+            "metrics_improvement": {
+                "Performance": "Improved",
+                "Recovery": "Complete"
+            },
+            "business_impact": {
+                "Cost Saved": f"${random.randint(2000, 8000):,}",
+                "Time Saved": f"{random.randint(30, 60)} min → {random.randint(5, 15)} min"
             }
-        
-        # Add ARF Enterprise context
-        results["arf_enterprise"] = {
-            "execution_complete": True,
-            "learning_applied": True,
-            "audit_trail_created": True,
-            "compliance_mode": "strict",
-            "roi_measured": True
         }
-        
-        # Create approval workflow display
-        approval_display = create_approval_workflow(approval_required)
-        
-        # Configuration
-        config = {
-            "approval_required": approval_required, 
-            "compliance_mode": "strict",
-            "arf_enterprise": True,
-            "safety_mode": "guardrails_active"
-        }
-        
-        return approval_display, config, results
     
-    def _simulate_enterprise_execution(self, scenario: IncidentScenario) -> Dict:
-        """Simulate enterprise execution for demo"""
-        actions = [
-            "✅ Auto-scaled resources based on ARF healing intent",
-            "✅ Implemented optimization recommendations",
-            "✅ Deployed monitoring and alerting",
-            "✅ Validated recovery with automated testing",
-            "✅ Updated RAG graph memory with learnings"
-        ]
-        
-        # Calculate improvements based on scenario
-        improvements = {}
-        for metric, value in scenario.metrics.items():
-            if "%" in value or any(x in metric.lower() for x in ['rate', 'load', 'time']):
-                try:
-                    current = float(''.join(filter(lambda x: x.isdigit() or x == '.', value.split()[0])))
-                    if current < 50:  # Low metrics (like cache hit rate)
-                        improved = min(100, current * random.uniform(2.5, 4.0))
-                    else:  # High metrics (like database load)
-                        improved = max(0, current * random.uniform(0.3, 0.6))
-                    
-                    if "%" in value:
-                        improvements[metric] = f"{current:.1f}% → {improved:.1f}%"
-                    elif "ms" in metric.lower():
-                        improvements[metric] = f"{current:.0f}ms → {improved:.0f}ms"
-                    else:
-                        improvements[metric] = f"{current:.0f} → {improved:.0f}"
-                except:
-                    improvements[metric] = f"{value} → Improved"
+    # Add approval info
+    if approval_required:
+        approval_html = f"""
+        <div style='padding: 15px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #007bff; margin: 10px 0;'>
+        <h4 style='margin: 0 0 10px 0;'>🛡️ Approval Required</h4>
+        <p><b>Action:</b> Scale resources for {scenario_name}</p>
+        <p><b>Risk:</b> Low (auto-rollback available)</p>
+        <p><b>Status:</b> ✅ <span style='color: green;'>Approved & Executed</span></p>
+        </div>
+        """
+    else:
+        approval_html = f"""
+        <div style='padding: 15px; background: #e8f5e8; border-radius: 8px; border-left: 4px solid #28a745; margin: 10px 0;'>
+        <h4 style='margin: 0 0 10px 0;'>⚡ Auto-Executed</h4>
+        <p><b>Action:</b> Autonomous healing for {scenario_name}</p>
+        <p><b>Mode:</b> Fully autonomous (guardrails active)</p>
+        <p><b>Status:</b> ✅ <span style='color: green;'>Successfully completed</span></p>
+        </div>
+        """
+    
+    # Add enterprise context
+    results["enterprise_context"] = {
+        "approval_required": approval_required,
+        "compliance_mode": "strict",
+        "audit_trail": "created",
+        "learning_applied": True,
+        "roi_measured": True
+    }
+    
+    return approval_html, {"approval_required": approval_required, "compliance_mode": "strict"}, results
+
+def calculate_roi(monthly_incidents: int, avg_impact: int, team_size: int):
+    """Calculate ROI"""
+    try:
+        annual_impact = monthly_incidents * 12 * avg_impact
+        team_cost = team_size * 150000
+        savings = annual_impact * 0.82
+        
+        roi_multiplier = savings / team_cost if team_cost > 0 else 0
+        
+        if roi_multiplier >= 5.0:
+            recommendation = "🚀 Excellent fit for ARF Enterprise"
+        elif roi_multiplier >= 2.0:
+            recommendation = "✅ Good ROI with ARF Enterprise"
+        elif roi_multiplier >= 1.0:
+            recommendation = "⚠️ Consider ARF OSS edition first"
+        else:
+            recommendation = "🆓 Start with ARF OSS (free)"
         
         return {
-            "actions_completed": actions,
-            "metrics_improvement": improvements,
-            "business_impact": {
-                "Recovery Time": f"60 min → {random.randint(5, 15)} min",
-                "Cost Saved": f"${random.randint(2000, 10000):,}",
-                "Users Impacted": "45,000 → 0",
-                "Revenue Protected": f"${random.randint(1000, 5000):,}",
-                "MTTR Improvement": f"{random.randint(75, 90)}% reduction"
+            "analysis": {
+                "your_annual_impact": f"${annual_impact:,.0f}",
+                "your_team_cost": f"${team_cost:,.0f}",
+                "potential_savings": f"${savings:,.0f}",
+                "your_roi_multiplier": f"{roi_multiplier:.1f}×",
+                "vs_industry_average": "5.2× average ROI",
+                "recommendation": recommendation,
+                "payback_period": f"{(team_cost / (savings / 12)):.1f} months" if savings > 0 else "N/A"
             }
         }
-    
-    def handle_roi_calculation(self, monthly_incidents: int,
-                              avg_impact: int, team_size: int) -> Dict:
-        """Handle ROI calculation"""
-        try:
-            return self.state.roi_calculator.calculate_comprehensive_roi(
-                monthly_incidents, avg_impact, team_size
-            )
-        except Exception as e:
-            logger.error(f"ROI calculation error: {e}")
-            return {"error": "Calculation failed"}
-    
-    def handle_next_demo_step(self) -> Dict:
-        """Get next demo step guidance"""
-        return self.state.demo_orchestrator.get_next_guidance()
+    except Exception as e:
+        return {"error": f"Calculation error: {str(e)}"}
 
 # ===========================================
 # MAIN INTERFACE
 # ===========================================
 
-def create_main_interface():
-    """Create the main Gradio interface"""
+def create_interface():
+    """Create the Gradio interface"""
     
-    state = ARFDemoState()
-    handlers = EventHandlers(state)
+    custom_css = """
+    .gradio-container { max-width: 1200px; margin: auto; }
+    h1, h2, h3 { color: #1a365d !important; }
+    """
     
     with gr.Blocks(
         title="🚀 ARF Investor Demo v3.6.0",
-        theme=THEME,
-        css=CUSTOM_CSS
+        theme=gr.themes.Soft(),
+        css=custom_css
     ) as demo:
         
-        # ============ HEADER WITH ARF VERSION ============
-        arf_status = "✅ ARF OSS v3.3.6" if ARF_OSS_AVAILABLE else "⚠️ ARF Simulation Mode"
+        # ============ HEADER ============
+        arf_status = "✅ ARF OSS v3.3.6" if ARF_OSS_AVAILABLE else "⚠️ Simulation Mode"
         
         gr.Markdown(f"""
         # 🚀 Agentic Reliability Framework - Investor Demo v3.6.0
@@ -450,134 +405,71 @@ def create_main_interface():
         </div>
         """)
         
-        # ============ ARF STATUS BADGE ============
-        if ARF_OSS_AVAILABLE:
-            gr.Markdown("""
-            <div style='
-                background: linear-gradient(135deg, #4ECDC4 0%, #44A08D 100%);
-                color: white;
-                padding: 10px 20px;
-                border-radius: 20px;
-                display: inline-block;
-                margin: 10px 0;
-                font-weight: bold;
-            '>
-            ✅ Connected to ARF OSS v3.3.6
-            </div>
-            """)
-        
-        # ============ PRESENTER GUIDANCE ============
-        gr.Markdown("### 🎯 Presenter Guidance")
-        with gr.Row():
-            next_step_btn = gr.Button("🎬 Next Demo Step", variant="secondary")
-            quick_demo_btn = gr.Button("⚡ Quick Demo Mode", variant="secondary", size="sm")
-        
-        guidance_display = gr.HTML(
-            value="<div class='presenter-guidance'>Click 'Next Demo Step' for guidance</div>"
-        )
-        
         # ============ MAIN TABS ============
         with gr.Tabs():
             
             # TAB 1: LIVE INCIDENT DEMO
-            with gr.TabItem("🔥 Live Incident Demo", id="live-demo"):
+            with gr.TabItem("🔥 Live Incident Demo"):
                 with gr.Row():
-                    # Left Panel - Incident Details
+                    # Left Panel
                     with gr.Column(scale=1):
                         gr.Markdown("### 🎬 Incident Scenario")
                         scenario_dropdown = gr.Dropdown(
-                            choices=state.get_scenario_names(),
+                            choices=list(INCIDENT_SCENARIOS.keys()),
                             value="Cache Miss Storm",
-                            label="Select critical incident:",
-                            interactive=True
+                            label="Select critical incident:"
                         )
                         
                         gr.Markdown("### 📊 Current Crisis Metrics")
                         metrics_display = gr.JSON(
-                            value=state.get_scenario("Cache Miss Storm").metrics,
-                            label="Live Metrics"
+                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["metrics"]
                         )
                         
                         gr.Markdown("### 💰 Business Impact")
                         impact_display = gr.JSON(
-                            value=state.get_scenario("Cache Miss Storm").impact,
-                            label="Impact Analysis"
+                            value=INCIDENT_SCENARIOS["Cache Miss Storm"]["impact"]
                         )
                     
-                    # Right Panel - Visualization & Actions
+                    # Right Panel
                     with gr.Column(scale=2):
-                        # Visualization Selector
-                        gr.Markdown("### 📈 Incident Visualization")
-                        viz_radio = gr.Radio(
-                            choices=["Interactive Timeline", "Executive Dashboard"],
-                            value="Interactive Timeline",
-                            label="Choose visualization:"
-                        )
-                        
-                        # Visualization Output
-                        timeline_output = gr.Plot(
-                            label="Visualization",
-                            show_label=False
-                        )
+                        # Visualization
+                        gr.Markdown("### 📈 Incident Timeline")
+                        timeline_output = gr.Plot()
                         
-                        # Action Section with ARF context
-                        gr.Markdown("### 🤖 ARF Analysis & Execution")
+                        # Action Buttons
                         with gr.Row():
-                            oss_btn = gr.Button("🆓 Run ARF OSS Analysis", variant="secondary")
+                            oss_btn = gr.Button("🆓 Run OSS Analysis", variant="secondary")
                             enterprise_btn = gr.Button("🚀 Execute Enterprise Healing", variant="primary")
                         
-                        # Approval Controls
-                        with gr.Row():
-                            approval_toggle = gr.Checkbox(
-                                label="🔐 Require Manual Approval",
-                                value=True,
-                                info="Toggle to show approval workflow vs auto-execution"
-                            )
-                        
-                        # ARF Context Information
-                        if ARF_OSS_AVAILABLE:
-                            gr.Markdown("""
-                            <div style='
-                                background: rgba(78, 205, 196, 0.1);
-                                padding: 10px;
-                                border-radius: 8px;
-                                border-left: 4px solid #4ECDC4;
-                                margin: 10px 0;
-                                font-size: 14px;
-                            '>
-                            <b>ARF OSS v3.3.6 Active</b><br>
-                            • Advisory healing intent creation<br>
-                            • RAG graph memory for pattern recall<br>
-                            • MCP safety layer (advisory mode)<br>
-                            • Apache 2.0 licensed
-                            </div>
-                            """)
+                        # Approval Toggle
+                        approval_toggle = gr.Checkbox(
+                            label="🔐 Require Manual Approval",
+                            value=True,
+                            info="Toggle to show approval workflow vs auto-execution"
+                        )
                         
-                        # Approval Workflow Display
-                        approval_display = gr.HTML()
+                        # Approval Display
+                        approval_display = gr.HTML(
+                            value="<div style='padding: 10px; background: #f8f9fa; border-radius: 5px;'>Approval status will appear here</div>"
+                        )
                         
                         # Configuration
                         config_display = gr.JSON(
                             label="⚙️ Enterprise Configuration",
-                            value={
-                                "approval_required": True, 
-                                "compliance_mode": "strict",
-                                "arf_enterprise": True,
-                                "safety_guardrails": "active"
-                            }
+                            value={"approval_required": True, "compliance_mode": "strict"}
                         )
                         
                         # Results
                         results_display = gr.JSON(
                             label="🎯 Execution Results",
-                            value={"status": "Ready for ARF analysis..."}
+                            value={"status": "Ready for execution..."}
                         )
             
             # TAB 2: BUSINESS IMPACT & ROI
-            with gr.TabItem("💰 Business Impact & ROI", id="business-roi"):
+            with gr.TabItem("💰 Business Impact & ROI"):
                 with gr.Column():
                     # Business Dashboard
-                    gr.Markdown("### 📊 Executive Business Dashboard")
+                    gr.Markdown("### 📊 Business Health Dashboard")
                     dashboard_output = gr.Plot()
                     
                     # ROI Calculator
@@ -590,7 +482,7 @@ def create_main_interface():
                             )
                             impact_slider = gr.Slider(
                                 1000, 50000, value=8500, step=500,
-                                label="Average incident impact ($)"
+                                label="Avg incident impact ($)"
                             )
                             team_slider = gr.Slider(
                                 1, 20, value=5, step=1,
@@ -601,200 +493,113 @@ def create_main_interface():
                         with gr.Column(scale=2):
                             roi_output = gr.JSON(
                                 label="Your ROI Analysis",
-                                value={"status": "Adjust sliders and click Calculate"}
+                                value={"analysis": "Adjust sliders and click 'Calculate My ROI'"}
                             )
                     
-                    # ARF ROI Context
-                    gr.Markdown("""
-                    <div style='
-                        background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
-                        padding: 20px;
-                        border-radius: 10px;
-                        margin: 20px 0;
-                    '>
-                        <h4 style='margin: 0 0 15px 0;'>📈 ARF ROI Measurement (Enterprise)</h4>
-                        <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 15px;'>
-                            <div>
-                                <div style='font-size: 24px; color: #4ECDC4;'>5.2×</div>
-                                <div style='font-size: 12px; color: #666;'>Average ROI</div>
-                            </div>
-                            <div>
-                                <div style='font-size: 24px; color: #4ECDC4;'>2-3 mo</div>
-                                <div style='font-size: 12px; color: #666;'>Payback Period</div>
-                            </div>
-                            <div>
-                                <div style='font-size: 24px; color: #4ECDC4;'>81.7%</div>
-                                <div style='font-size: 12px; color: #666;'>Auto-Heal Rate</div>
-                            </div>
-                            <div>
-                                <div style='font-size: 24px; color: #4ECDC4;'>85%</div>
-                                <div style='font-size: 12px; color: #666;'>MTTR Reduction</div>
-                            </div>
-                        </div>
-                    </div>
-                    """)
-                    
                     # Capability Comparison
-                    comparison_table = create_roi_comparison_table()
+                    gr.Markdown("### 📋 Capability Comparison")
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("""
+                            **OSS Edition (Free)**
+                            - Advisory recommendations only
+                            - Manual implementation required
+                            - No auto-healing
+                            - Community support
+                            - No ROI measurement
+                            """)
+                        with gr.Column():
+                            gr.Markdown("""
+                            **Enterprise Edition**
+                            - Autonomous execution
+                            - 81.7% auto-heal rate
+                            - Full audit trails & compliance
+                            - 24/7 enterprise support
+                            - 5.2× average ROI
+                            - 2-3 month payback
+                            """)
         
         # ============ FOOTER ============
         gr.Markdown("---")
         with gr.Row():
             with gr.Column(scale=2):
-                arf_links = """
-                **📦 ARF OSS v3.3.6**
-                <div style='margin-top: 10px;'>
-                📚 <b>PyPI:</b> <a href='https://pypi.org/project/agentic-reliability-framework/' target='_blank'>agentic-reliability-framework</a><br>
-                💻 <b>GitHub:</b> <a href='https://github.com/petterjuan/agentic-reliability-framework' target='_blank'>petterjuan/agentic-reliability-framework</a><br>
-                📄 <b>License:</b> Apache 2.0
-                </div>
-                """
-                
-                contact_info = """
-                **📞 Contact & Enterprise**
-                <div style='margin-top: 10px;'>
-                📧 <b>Email:</b> enterprise@arf.dev<br>
-                🌐 <b>Website:</b> <a href='https://arf.dev' target='_blank'>https://arf.dev</a><br>
-                📚 <b>Docs:</b> <a href='https://docs.arf.dev' target='_blank'>https://docs.arf.dev</a>
-                </div>
-                """
-                
-                gr.Markdown(f"""
-                <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 40px;'>
-                    <div>{arf_links}</div>
-                    <div>{contact_info}</div>
-                </div>
+                gr.Markdown("""
+                **📞 Contact & Demo**  
+                📧 petter2025us@outlook.com  
+                🌐 [https://arf.dev](https://arf.dev)  
+                📚 [Documentation](https://docs.arf.dev)  
+                💻 [GitHub](https://github.com/petterjuan/agentic-reliability-framework)
                 """)
-            
             with gr.Column(scale=1):
                 gr.Markdown("""
-                **🎯 Schedule a Demo**
-                <div style='margin-top: 10px;'>
-                <a href='https://arf.dev/demo' target='_blank' style='
-                    display: inline-block;
-                    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
-                    color: white;
-                    padding: 12px 24px;
-                    border-radius: 8px;
-                    text-decoration: none;
-                    font-weight: bold;
-                    text-align: center;
-                '>Schedule Enterprise Demo →</a>
-                </div>
+                **🎯 Schedule a Demo**  
+                (https://calendly.com/petter2025us/30min)
                 """)
         
         # ============ EVENT HANDLERS ============
         
-        # Scenario changes
-        scenario_dropdown.change(
-            handlers.handle_scenario_change,
-            inputs=[scenario_dropdown, viz_radio],
-            outputs=[metrics_display, impact_display, timeline_output]
-        )
+        def update_scenario(scenario_name: str):
+            """Update when scenario changes"""
+            scenario = INCIDENT_SCENARIOS.get(scenario_name, {})
+            return (
+                scenario.get("metrics", {}),
+                scenario.get("impact", {}),
+                create_timeline_visualization()
+            )
         
-        viz_radio.change(
-            handlers.handle_scenario_change,
-            inputs=[scenario_dropdown, viz_radio],
+        # Scenario change
+        scenario_dropdown.change(
+            update_scenario,
+            inputs=[scenario_dropdown],
             outputs=[metrics_display, impact_display, timeline_output]
         )
         
-        # OSS Analysis (using actual ARF)
+        # OSS Analysis
         oss_btn.click(
-            handlers.handle_oss_analysis,
+            run_oss_analysis,
             inputs=[scenario_dropdown],
             outputs=[results_display]
         )
         
         # Enterprise Execution
         enterprise_btn.click(
-            handlers.handle_enterprise_execution,
+            execute_enterprise_healing,
             inputs=[scenario_dropdown, approval_toggle],
             outputs=[approval_display, config_display, results_display]
         )
         
         # Approval toggle updates config
         approval_toggle.change(
-            lambda approval: {
-                "approval_required": approval, 
-                "compliance_mode": "strict",
-                "arf_enterprise": True,
-                "safety_guardrails": "active"
-            },
+            lambda approval: {"approval_required": approval, "compliance_mode": "strict"},
             inputs=[approval_toggle],
             outputs=[config_display]
         )
         
         # ROI Calculation
         calculate_btn.click(
-            handlers.handle_roi_calculation,
+            calculate_roi,
             inputs=[monthly_slider, impact_slider, team_slider],
             outputs=[roi_output]
         )
         
-        # Next demo step guidance
-        next_step_btn.click(
-            handlers.handle_next_demo_step,
-            outputs=[guidance_display]
-        )
-        
-        # Quick demo button - runs OSS analysis automatically
-        quick_demo_btn.click(
-            lambda scenario: handlers.handle_oss_analysis(scenario),
-            inputs=[scenario_dropdown],
-            outputs=[results_display]
-        )
-        
         # ============ INITIAL LOAD ============
-        
-        def load_initial_state():
-            """Load initial visualizations and data"""
-            # Get initial scenario
-            scenario = state.get_scenario("Cache Miss Storm")
-            
-            # Create visualizations
-            timeline_viz = state.viz_engine.create_interactive_timeline(scenario)
-            dashboard_viz = state.viz_engine.create_executive_dashboard()
-            
-            # Get initial guidance
-            guidance = state.demo_orchestrator.get_next_guidance()
-            
-            # Add ARF status
-            arf_status_html = ""
-            if ARF_OSS_AVAILABLE:
-                arf_status_html = """
-                <div style='
-                    background: rgba(78, 205, 196, 0.1);
-                    padding: 10px;
-                    border-radius: 8px;
-                    border-left: 4px solid #4ECDC4;
-                    margin: 10px 0;
-                '>
-                    ✅ <b>ARF OSS v3.3.6 Loaded</b> - Real framework analysis available
-                </div>
-                """
-            
+        def load_initial():
+            """Load initial state"""
             return (
-                scenario.metrics if scenario else {},
-                scenario.impact if scenario else {},
-                timeline_viz,
-                dashboard_viz,
-                arf_status_html + guidance["html"]
+                INCIDENT_SCENARIOS["Cache Miss Storm"]["metrics"],
+                INCIDENT_SCENARIOS["Cache Miss Storm"]["impact"],
+                create_timeline_visualization(),
+                create_business_dashboard()
             )
         
         demo.load(
-            load_initial_state,
-            outputs=[
-                metrics_display, 
-                impact_display, 
-                timeline_output, 
-                dashboard_output,
-                guidance_display
-            ]
+            load_initial,
+            outputs=[metrics_display, impact_display, timeline_output, dashboard_output]
         )
         
         # ============ INSTRUCTIONS ============
         gr.Markdown(f"""
-        <div class='footer'>
+        <div style='margin-top: 40px; padding-top: 20px; border-top: 1px solid #e2e8f0; color: #718096; font-size: 14px;'>
         🚀 <b>ARF Ultimate Investor Demo v3.6.0</b> | {'✅ Integrated with ARF OSS v3.3.6' if ARF_OSS_AVAILABLE else '⚠️ Running in simulation mode'}  
         <i>From Cost Center to Profit Engine: 5.2× ROI with Autonomous Reliability</i>
         </div>
@@ -803,27 +608,21 @@ def create_main_interface():
     return demo
 
 # ===========================================
-# APPLICATION ENTRY POINT
+# MAIN
 # ===========================================
 
-def main():
-    """Main entry point"""
+if __name__ == "__main__":
     logger.info("=" * 80)
     logger.info("🚀 Launching ARF Investor Demo v3.6.0")
     logger.info(f"✅ ARF OSS Available: {ARF_OSS_AVAILABLE}")
-    logger.info("✅ Integrated with actual ARF OSS package")
-    logger.info("✅ Best practices applied")
-    logger.info("✅ Investor-grade UX")
+    logger.info("✅ Standalone version - No module dependencies")
     logger.info("=" * 80)
     
-    demo = create_main_interface()
+    demo = create_interface()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         debug=False,
         show_error=True
-    )
-
-if __name__ == "__main__":
-    main()
+    )