Update core/true_arf_orchestrator.py

core/true_arf_orchestrator.py

@@ -29,6 +29,9 @@ class TrueARF337Orchestrator:
         except ImportError as e:
             logger.warning(f"True ARF OSS not available: {e}")
             self.true_oss = None
+        except Exception as e:
+            logger.error(f"Error initializing True ARF OSS: {e}")
+            self.true_oss = None
         
         try:
             from core.enterprise_simulation import get_enterprise_simulation
@@ -37,6 +40,9 @@ class TrueARF337Orchestrator:
         except ImportError as e:
             logger.warning(f"Enterprise simulation not available: {e}")
             self.enterprise_sim = None
+        except Exception as e:
+            logger.error(f"Error initializing Enterprise simulation: {e}")
+            self.enterprise_sim = None
     
     async def analyze_incident(self, scenario_name: str, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -50,19 +56,31 @@ class TrueARF337Orchestrator:
             # 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)
+                try:
+                    true_oss_instance = await self.true_oss()
+                    if hasattr(true_oss_instance, 'oss_available') and true_oss_instance.oss_available:
+                        oss_analysis = await true_oss_instance.analyze_scenario(scenario_name, scenario_data)
+                    else:
+                        logger.warning("True ARF OSS not available - using fallback mock")
+                        oss_analysis = await self._fallback_oss_analysis(scenario_name, scenario_data)
+                except Exception as e:
+                    logger.error(f"Error in true OSS analysis: {e}")
+                    oss_analysis = await self._fallback_oss_analysis(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
-                )
+            if self.enterprise_sim and oss_analysis and oss_analysis.get("status") == "success":
+                try:
+                    enterprise_instance = await self.enterprise_sim()
+                    enterprise_enhancements = await enterprise_instance.enhance_oss_analysis(
+                        oss_analysis, scenario_name
+                    )
+                except Exception as e:
+                    logger.error(f"Error in enterprise enhancement: {e}")
+                    # Continue without enterprise enhancements
             
             # Combine results
             result = {
@@ -82,43 +100,52 @@ class TrueARF337Orchestrator:
             logger.error(f"Analysis failed: {e}", exc_info=True)
             return {
                 "status": "error",
-                "error": str(e),
-                "scenario": scenario_name
+                "error": f"Analysis failed: {str(e)}",  # Make sure error is a string
+                "scenario": scenario_name,
+                "suggestion": "Check logs for details"
             }
     
     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"
-        }
+        try:
+            # 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"
+            }
+        except Exception as e:
+            logger.error(f"Fallback analysis failed: {e}")
+            return {
+                "status": "error",
+                "error": f"Fallback analysis failed: {str(e)}",
+                "scenario": scenario_name
+            }
     
     def _get_recommendation(self, oss_analysis: Dict, enterprise_enhancements: Dict) -> str:
         """Generate recommendation based on analysis"""