Update demo/orchestrator.py

demo/orchestrator.py

@@ -1,178 +1,163 @@
 """
-Demo orchestration and presenter guidance
+Demo Orchestrator - Integrates with ARF OSS framework
 """
 
-from typing import Dict, List, Optional
-from enum import Enum
-from core.data_models import DemoMode, DemoStep
+import asyncio
+import json
+import datetime
+from typing import Dict, List, Any, Optional, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 class DemoOrchestrator:
-    """Guide presenter through optimal demo flow"""
+    """Orchestrates the demo workflow using ARF OSS"""
     
-    def __init__(self, mode: DemoMode = DemoMode.INVESTOR):
-        self.mode = mode
-        self.current_step = 0
-        self.steps = self._get_steps_for_mode()
+    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
+        }
         
-    def _get_steps_for_mode(self) -> List[DemoStep]:
-        """Get demo steps based on mode"""
-        if self.mode == DemoMode.QUICK:
-            return [
-                DemoStep(
-                    title="Show Crisis",
-                    scenario="Cache Miss Storm",
-                    action="metrics",
-                    message="Highlight the critical metrics - this is happening right now",
-                    icon="📊"
-                ),
-                DemoStep(
-                    title="OSS Analysis",
-                    scenario="Cache Miss Storm",
-                    action="oss",
-                    message="Perfect analysis but requires manual work",
-                    icon="🤖"
-                ),
-                DemoStep(
-                    title="Enterprise Magic",
-                    scenario="Cache Miss Storm",
-                    action="enterprise",
-                    message="Watch ARF fix it automatically in minutes",
-                    icon="⚡"
+    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}
                 )
-            ]
-        else:  # INVESTOR mode
-            return [
-                DemoStep(
-                    title="Problem Statement",
-                    scenario="Cache Miss Storm",
-                    action="metrics",
-                    message="This critical incident costs $8,500/hour right now",
-                    icon="💰"
-                ),
-                DemoStep(
-                    title="Current Solution (OSS)",
-                    scenario="Cache Miss Storm",
-                    action="oss",
-                    message="Our free edition gives perfect analysis but manual work",
-                    icon="🆓"
-                ),
-                DemoStep(
-                    title="ARF Solution (Enterprise)",
-                    scenario="Cache Miss Storm",
-                    action="enterprise",
-                    message="Autonomous healing with enterprise safety controls",
-                    icon="🚀"
-                ),
-                DemoStep(
-                    title="Business Impact",
-                    scenario=None,
-                    action="dashboard",
-                    message="Show how ARF transforms cost centers to profit engines",
-                    icon="📈"
-                ),
-                DemoStep(
-                    title="Custom ROI Analysis",
-                    scenario=None,
-                    action="roi_calc",
-                    message="Calculate their specific potential savings",
-                    icon="🧮"
-                )
-            ]
+                
+                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)
+            }
+    
+    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"
+            }
+        }
+        
+        self.execution_history.append(execution_record)
+        
+        # Update learning stats
+        self.learning_stats["patterns_detected"] += 1
+        
+        return execution_record
     
-    def get_next_guidance(self) -> Dict:
-        """Get next guidance step"""
-        if self.current_step >= len(self.steps):
-            return self._create_completion_guidance()
+    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]
+    
+    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)
         
-        step = self.steps[self.current_step]
-        self.current_step += 1
+        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
         
         return {
-            "title": step.title,
-            "scenario": step.scenario,
-            "action": step.action,
-            "message": step.message,
-            "icon": step.icon,
-            "html": self._create_guidance_html(step)
+            "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)
         }
     
-    def _create_guidance_html(self, step: DemoStep) -> str:
-        """Create HTML guidance for presenter"""
-        action_desc = self._get_action_description(step.action)
-        
-        return f"""
-        <div style='
-            padding: 20px;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            border-radius: 10px;
-            margin: 15px 0;
-            border-left: 5px solid #4ECDC4;
-            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-        '>
-            <div style='display: flex; align-items: center; margin-bottom: 10px;'>
-                <span style='font-size: 24px; margin-right: 10px;'>{step.icon}</span>
-                <h3 style='margin: 0;'>Step {self.current_step}: {step.title}</h3>
-            </div>
-            <p style='margin: 0 0 10px 0; font-size: 16px;'><b>What to say:</b> "{step.message}"</p>
-            <div style='
-                background: rgba(255,255,255,0.1);
-                padding: 10px;
-                border-radius: 5px;
-                margin-top: 10px;
-            '>
-                <span style='font-size: 14px; opacity: 0.9;'>👆 <b>Action:</b> {action_desc}</span>
-            </div>
-        </div>
-        """
+    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)"
     
-    def _create_completion_guidance(self) -> Dict:
-        """Create completion guidance"""
+    def get_audit_trail(self) -> Dict:
+        """Get complete audit trail"""
         return {
-            "title": "Demo Complete",
-            "scenario": None,
-            "action": "complete",
-            "message": "Ready for investor Q&A",
-            "icon": "🎉",
-            "html": """
-            <div style='
-                padding: 25px;
-                background: linear-gradient(135deg, #4ECDC4 0%, #44A08D 100%);
-                color: white;
-                border-radius: 10px;
-                text-align: center;
-                margin: 20px 0;
-                box-shadow: 0 4px 6px rgba(0,0,0,0.1);
-            '>
-                <h2 style='margin: 0 0 15px 0;'>🎉 Demo Complete!</h2>
-                <p style='margin: 0; font-size: 18px;'>Ready for investor Q&A</p>
-                <div style='
-                    margin-top: 20px;
-                    padding: 15px;
-                    background: rgba(255,255,255,0.1);
-                    border-radius: 8px;
-                    text-align: left;
-                '>
-                    <h4 style='margin: 0 0 10px 0;'>Key Metrics Demonstrated:</h4>
-                    <div style='display: grid; grid-template-columns: 1fr 1fr; gap: 10px;'>
-                        <div>• 85% faster incident resolution</div>
-                        <div>• 5.2× average ROI</div>
-                        <div>• 81.7% auto-heal rate</div>
-                        <div>• 2-3 month payback</div>
-                    </div>
-                </div>
-            </div>
-            """
+            "incidents": self.incident_history,
+            "executions": self.execution_history,
+            "learning_stats": self.learning_stats,
+            "exported_at": datetime.datetime.now().isoformat()
         }
     
-    def _get_action_description(self, action: str) -> str:
-        """Get description for action"""
-        actions = {
-            "metrics": "Show crisis metrics (already displayed)",
-            "oss": "Click 'Run OSS Analysis' button",
-            "enterprise": "Click 'Execute Enterprise Healing' (toggle approval)",
-            "dashboard": "Switch to Business Impact tab",
-            "roi_calc": "Adjust sliders and calculate custom ROI",
-            "complete": "Proceed to Q&A"
-        }
-        return actions.get(action, "Continue with demo")
+    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
+        }