Update demo/orchestrator.py

demo/orchestrator.py

@@ -1,163 +1,180 @@
 """
-Demo Orchestrator - Integrates with ARF OSS framework
+Enhanced demo orchestrator with real ARF integration patterns
 """
-
-import asyncio
+import streamlit as st
+import time
 import json
-import datetime
-from typing import Dict, List, Any, Optional, Tuple
-import logging
-
-logger = logging.getLogger(__name__)
+from datetime import datetime
+from typing import Dict, Any, List, Optional
 
+# Import mock ARF components
+from .scenarios import get_scenario_data
+from .mock_arf import (
+    create_mock_healing_intent,
+    run_rag_similarity_search,
+    calculate_pattern_confidence,
+    simulate_arf_analysis
+)
 
-class DemoOrchestrator:
-    """Orchestrates the demo workflow using ARF OSS"""
+def run_enhanced_incident_demo(scenario_name: str, execution_mode: str = "advisory"):
+    """
+    Run enhanced incident demo with ARF integration
+    """
+    # Get scenario data
+    scenario = get_scenario_data(scenario_name)
+    if not scenario:
+        st.error(f"Scenario '{scenario_name}' not found")
+        return
+    
+    # Display incident header
+    st.markdown(f"### 🔥 {scenario['name']}")
+    st.caption(scenario['description'])
     
-    def __init__(self, arf_client=None):
-        self.arf_client = arf_client
-        self.incident_history = []
-        self.execution_history = []
-        self.learning_stats = {
-            "patterns_detected": 0,
-            "similar_incidents_found": 0,
-            "healing_intents_created": 0
-        }
+    # Create columns for metrics and business impact
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("#### 📊 Current Metrics")
+        metrics = scenario.get('metrics', {})
         
-    async def analyze_incident(self, scenario_name: str, scenario_data: Dict) -> Dict:
-        """Analyze incident using ARF OSS"""
-        try:
-            if self.arf_client and hasattr(self.arf_client, 'analyze_and_recommend'):
-                # Use actual ARF OSS analysis
-                healing_intent = await self.arf_client.analyze_and_recommend(
-                    tool_name="analyze",
-                    component=scenario_data.get("component", "unknown"),
-                    parameters=scenario_data.get("metrics", {}),
-                    context={"scenario": scenario_name}
-                )
-                
-                self.learning_stats["healing_intents_created"] += 1
-                
-                return {
-                    "status": "success",
-                    "healing_intent": healing_intent.to_enterprise_request(),
-                    "analysis": {
-                        "confidence": healing_intent.confidence,
-                        "similar_incidents": healing_intent.similar_incidents,
-                        "recommendation": healing_intent.justification
-                    }
-                }
-            
-            # Fallback to mock analysis
-            return {
-                "status": "success",
-                "analysis": {
-                    "confidence": 0.85,
-                    "similar_incidents": [
-                        {"id": "inc_001", "similarity": 0.78, "component": "redis"},
-                        {"id": "inc_045", "similarity": 0.65, "component": "database"}
-                    ],
-                    "recommendation": f"Based on 2 similar incidents, recommend action for {scenario_name}"
-                }
-            }
-            
-        except Exception as e:
-            logger.error(f"Analysis failed: {e}")
-            return {
-                "status": "error",
-                "message": str(e)
-            }
+        # Create metrics display
+        metrics_cols = st.columns(2)
+        for idx, (key, value) in enumerate(metrics.items()):
+            with metrics_cols[idx % 2]:
+                if isinstance(value, (int, float)):
+                    if key == "cache_hit_rate":
+                        st.metric(label=key.replace('_', ' ').title(), 
+                                 value=f"{value}%",
+                                 delta="-65%" if value < 20 else None)
+                    elif key == "database_load":
+                        st.metric(label=key.replace('_', ' ').title(),
+                                 value=f"{value}%",
+                                 delta="+40%" if value > 80 else None)
+                    else:
+                        st.metric(label=key.replace('_', ' ').title(), value=str(value))
     
-    def execute_healing(self, scenario_name: str, healing_intent: Dict, 
-                       mode: str = "autonomous") -> Dict:
-        """Execute healing action"""
-        execution_record = {
-            "id": f"exec_{len(self.execution_history):03d}",
-            "scenario": scenario_name,
-            "timestamp": datetime.datetime.now().isoformat(),
-            "mode": mode,
-            "healing_intent": healing_intent,
-            "status": "completed",
-            "results": {
-                "recovery_time_minutes": 12,
-                "cost_saved": 7200,
-                "users_impacted": "45,000 → 0"
-            }
-        }
+    with col2:
+        st.markdown("#### 💰 Business Impact")
+        impact = scenario.get('business_impact', {})
         
-        self.execution_history.append(execution_record)
+        if impact.get('revenue_loss_per_hour'):
+            st.metric(
+                label="Revenue Loss/Hour",
+                value=f"${impact['revenue_loss_per_hour']:,.0f}",
+                delta_color="inverse"
+            )
         
-        # Update learning stats
-        self.learning_stats["patterns_detected"] += 1
+        if impact.get('sla_violation'):
+            st.error("⚠️ SLA Violation Detected")
         
-        return execution_record
-    
-    def get_similar_incidents(self, query: str, limit: int = 5) -> List[Dict]:
-        """Find similar incidents"""
-        # This would integrate with ARF's RAG memory
-        return [
-            {
-                "id": "inc_001",
-                "similarity": 0.92,
-                "scenario": "Cache Miss Storm",
-                "resolution": "Scaled Redis cluster + circuit breaker",
-                "recovery_time": "12 minutes"
-            },
-            {
-                "id": "inc_045",
-                "similarity": 0.78,
-                "scenario": "Database Connection Pool",
-                "resolution": "Increased pool size + monitoring",
-                "recovery_time": "18 minutes"
-            }
-        ][:limit]
+        if impact.get('affected_users'):
+            st.metric(
+                label="Affected Users",
+                value=f"{impact['affected_users']:,.0f}",
+                delta_color="inverse"
+            )
     
-    def calculate_roi(self, company_data: Dict) -> Dict:
-        """Calculate ROI based on company data"""
-        monthly_incidents = company_data.get("monthly_incidents", 10)
-        avg_cost_per_incident = company_data.get("avg_cost_per_incident", 5000)
-        team_size = company_data.get("team_size", 3)
+    # Run ARF analysis
+    with st.spinner("🧠 ARF Analysis in progress..."):
+        time.sleep(1.5)
         
-        annual_impact = monthly_incidents * 12 * avg_cost_per_incident
-        team_cost = team_size * 150000  # $150k per engineer
-        savings = annual_impact * 0.82  # 82% savings with ARF
-        roi_multiplier = savings / team_cost if team_cost > 0 else 0
+        # Simulate ARF analysis pipeline
+        arf_analysis = simulate_arf_analysis(scenario)
         
-        return {
-            "annual_impact": annual_impact,
-            "team_cost": team_cost,
-            "potential_savings": savings,
-            "roi_multiplier": roi_multiplier,
-            "payback_months": (team_cost / (savings / 12)) if savings > 0 else 0,
-            "recommendation": self._get_roi_recommendation(roi_multiplier)
-        }
+        # Run RAG similarity search
+        similar_incidents = run_rag_similarity_search(scenario)
+        
+        # Calculate pattern confidence
+        pattern_confidence = calculate_pattern_confidence(scenario, similar_incidents)
+        
+        # Create HealingIntent
+        healing_intent = create_mock_healing_intent(
+            scenario=scenario,
+            similar_incidents=similar_incidents,
+            confidence=pattern_confidence
+        )
+    
+    # Display enhanced timeline with ARF integration
+    from ..ui.components import create_arf_enhanced_timeline
+    create_arf_enhanced_timeline(scenario, [healing_intent])
     
-    def _get_roi_recommendation(self, roi_multiplier: float) -> str:
-        """Get recommendation based on ROI"""
-        if roi_multiplier >= 5.0:
-            return "🚀 Excellent fit for ARF Enterprise"
-        elif roi_multiplier >= 2.0:
-            return "✅ Good ROI with ARF Enterprise"
-        elif roi_multiplier >= 1.0:
-            return "⚠️ Consider ARF OSS edition first"
-        else:
-            return "🆓 Start with ARF OSS (free)"
+    # Show HealingIntent visualizer
+    from ..ui.components import create_healing_intent_visualizer
+    create_healing_intent_visualizer(healing_intent)
     
-    def get_audit_trail(self) -> Dict:
-        """Get complete audit trail"""
-        return {
-            "incidents": self.incident_history,
-            "executions": self.execution_history,
-            "learning_stats": self.learning_stats,
-            "exported_at": datetime.datetime.now().isoformat()
-        }
+    # Show RAG similarity panel
+    from ..ui.components import create_rag_similarity_panel
+    create_rag_similarity_panel(
+        query=f"{scenario['name']} - {scenario['description']}",
+        similar_incidents=similar_incidents
+    )
     
-    def reset_demo(self):
-        """Reset demo state"""
-        self.incident_history = []
-        self.execution_history = []
-        self.learning_stats = {
-            "patterns_detected": 0,
-            "similar_incidents_found": 0,
-            "healing_intents_created": 0
-        }
+    # Show execution mode differences
+    from ..ui.components import create_execution_mode_toggle
+    selected_mode = create_execution_mode_toggle(execution_mode)
+    
+    # Action buttons based on mode
+    st.markdown("---")
+    st.markdown("### ⚡ Take Action")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("🆓 Run OSS Analysis", use_container_width=True):
+            st.info("""
+            **OSS Analysis Results:**
+            - Incident identified: Cache miss storm
+            - Recommended action: Scale Redis cluster
+            - Confidence: 85%
+            - Similar incidents found: 3
+            
+            *Note: OSS edition provides analysis only.*
+            """)
+    
+    with col2:
+        if st.button("🚀 Execute Enterprise Healing", use_container_width=True):
+            if execution_mode == "advisory":
+                st.warning("""
+                **Enterprise Upgrade Required**
+                
+                To execute healing actions, upgrade to Enterprise Edition:
+                - Autonomous healing capabilities
+                - Approval workflows
+                - Audit trails
+                - Compliance reporting
+                
+                [Upgrade Now](https://arf.dev/enterprise)
+                """)
+            elif execution_mode == "approval":
+                st.success("""
+                **Healing Action Submitted for Approval**
+                
+                ✅ HealingIntent created
+                📋 Sent to approval workflow
+                👤 Awaiting human review
+                🕐 Estimated approval time: 2-5 minutes
+                """)
+            else:  # autonomous
+                st.success("""
+                **Autonomous Healing Executed**
+                
+                ✅ Redis cluster scaled from 3 to 5 nodes
+                ✅ Cache TTL adjusted to 300s
+                ✅ Database connections optimized
+                ⚡ Resolution time: 8.2 minutes
+                💰 Cost avoided: $7,225
+                """)
+    
+    with col3:
+        if st.button("🔐 Require Manual Approval", use_container_width=True):
+            st.info("""
+            **Approval Workflow Enabled**
+            
+            This incident will require manual approval before execution:
+            1. SRE team notified via PagerDuty
+            2. Approval required from team lead
+            3. Audit trail recorded
+            4. Compliance checks run
+            
+            *Enterprise feature: Human-in-the-loop safety*
+            """)