Create true_arf_orchestrator.py

core/true_arf_orchestrator.py

@@ -0,0 +1,133 @@
+"""
+Updated orchestrator that combines:
+1. True ARF OSS v3.3.7 for real advisory analysis
+2. Enterprise simulation to show value proposition
+"""
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+class TrueARF337Orchestrator:
+    """
+    True ARF v3.3.7 orchestrator with:
+    - Real OSS package for advisory analysis
+    - Enterprise simulation to show upgrade value
+    """
+    
+    def __init__(self):
+        self.true_oss = None
+        self.enterprise_sim = None
+        self._initialize_components()
+    
+    def _initialize_components(self):
+        """Initialize true ARF components"""
+        try:
+            from core.true_arf_oss import get_true_arf_oss
+            self.true_oss = get_true_arf_oss
+            logger.info("✅ True ARF OSS v3.3.7 component available")
+        except ImportError as e:
+            logger.warning(f"True ARF OSS not available: {e}")
+            self.true_oss = None
+        
+        try:
+            from core.enterprise_simulation import get_enterprise_simulation
+            self.enterprise_sim = get_enterprise_simulation
+            logger.info("✅ Enterprise simulation component available")
+        except ImportError as e:
+            logger.warning(f"Enterprise simulation not available: {e}")
+            self.enterprise_sim = None
+    
+    async def analyze_incident(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Complete analysis using:
+        1. True ARF OSS v3.3.7 for real advisory analysis
+        2. Enterprise simulation to show upgrade value
+        """
+        logger.info(f"Running true ARF v3.3.7 analysis for: {scenario_name}")
+        
+        try:
+            # Step 1: Run true OSS analysis
+            oss_analysis = None
+            if self.true_oss:
+                true_oss_instance = await self.true_oss()
+                oss_analysis = await true_oss_instance.analyze_scenario(scenario_name, scenario_data)
+            else:
+                # Fallback to mock
+                oss_analysis = await self._fallback_oss_analysis(scenario_name, scenario_data)
+            
+            # Step 2: Enhance with Enterprise features (simulation)
+            enterprise_enhancements = None
+            if self.enterprise_sim and oss_analysis.get("status") == "success":
+                enterprise_instance = await self.enterprise_sim()
+                enterprise_enhancements = await enterprise_instance.enhance_oss_analysis(
+                    oss_analysis, scenario_name
+                )
+            
+            # Combine results
+            result = {
+                "status": "success",
+                "scenario": scenario_name,
+                "arf_version": "3.3.7",
+                "true_oss_used": self.true_oss is not None,
+                "enterprise_simulated": self.enterprise_sim is not None,
+                "oss_analysis": oss_analysis,
+                "enterprise_enhancements": enterprise_enhancements,
+                "recommendation": self._get_recommendation(oss_analysis, enterprise_enhancements)
+            }
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Analysis failed: {e}", exc_info=True)
+            return {
+                "status": "error",
+                "error": str(e),
+                "scenario": scenario_name
+            }
+    
+    async def _fallback_oss_analysis(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Fallback mock analysis"""
+        # Use existing mock ARF with scenario-aware metrics
+        from demo.mock_arf import (
+            simulate_arf_analysis,
+            run_rag_similarity_search,
+            calculate_pattern_confidence,
+            create_mock_healing_intent
+        )
+        
+        scenario_data_with_name = scenario_data.copy()
+        scenario_data_with_name["name"] = scenario_name
+        
+        detection = simulate_arf_analysis(scenario_data_with_name)
+        recall = run_rag_similarity_search(scenario_data_with_name)
+        confidence = calculate_pattern_confidence(scenario_data_with_name, recall)
+        decision = create_mock_healing_intent(scenario_data_with_name, recall, confidence)
+        
+        return {
+            "status": "success",
+            "scenario": scenario_name,
+            "analysis": {
+                "detection": detection,
+                "recall": recall,
+                "decision": decision
+            },
+            "capabilities": {
+                "execution_allowed": False,
+                "mcp_modes": ["advisory"],
+                "oss_boundary": "advisory_only"
+            },
+            "note": "Using fallback mock analysis"
+        }
+    
+    def _get_recommendation(self, oss_analysis: Dict, enterprise_enhancements: Dict) -> str:
+        """Generate recommendation based on analysis"""
+        if not oss_analysis or oss_analysis.get("status") != "success":
+            return "Analysis failed. Check logs."
+        
+        if enterprise_enhancements and enterprise_enhancements.get("enterprise_available"):
+            return "✅ Both OSS and Enterprise features available. Full ARF v3.3.7 capabilities enabled."
+        elif enterprise_enhancements:
+            return "✅ OSS analysis complete. ⚡ Enterprise features simulated - shows upgrade value. Contact sales@arf.dev for Enterprise trial."
+        else:
+            return "✅ OSS analysis complete. Install agentic-reliability-framework==3.3.7 for real advisory capabilities."