Delete utils

utils/async_runner.py

@@ -1,243 +0,0 @@
-"""
-Enhanced Async Utilities for Safe Async/Sync Integration
-FIXED VERSION: Consolidated from app.py with nest_asyncio compatibility and better error handling
-"""
-import asyncio
-import functools
-import time
-import logging
-from typing import Any, Callable, Coroutine, Optional, TypeVar, Union
-from contextlib import contextmanager
-
-logger = logging.getLogger(__name__)
-T = TypeVar('T')
-
-class AsyncRunner:
-    """
-    Enhanced async runner with nest_asyncio compatibility and robust error handling
-    Consolidated from app.py local implementation
-    """
-    
-    @staticmethod
-    def run_async(coro: Coroutine[Any, Any, T], timeout: Optional[float] = 30.0) -> Union[T, dict]:
-        """
-        FIXED: Run async coroutine in sync context with nest_asyncio compatibility
-        
-        Args:
-            coro: Async coroutine to run
-            timeout: Maximum time to wait for coroutine completion (seconds)
-            
-        Returns:
-            Result of the coroutine or error dictionary if failed
-        """
-        start_time = time.time()
-        
-        try:
-            # Try to get running loop first (nest_asyncio compatible)
-            try:
-                loop = asyncio.get_running_loop()
-                logger.debug("✅ Running in existing async context (nest_asyncio detected)")
-                
-                # In a running loop, we need to schedule as a task
-                # This handles the "event loop already running" case
-                task = asyncio.create_task(coro)
-                
-                # For sync context, we need to run until complete
-                # Use asyncio.run_coroutine_threadsafe for thread safety
-                import concurrent.futures
-                future = asyncio.run_coroutine_threadsafe(coro, loop)
-                
-                try:
-                    result = future.result(timeout=timeout)
-                    logger.debug(f"✅ Async execution completed in {time.time() - start_time:.2f}s")
-                    return result
-                except concurrent.futures.TimeoutError:
-                    logger.error(f"❌ Async execution timed out after {timeout}s")
-                    future.cancel()
-                    return {
-                        "error": f"Async execution timed out after {timeout}s",
-                        "status": "failed",
-                        "timeout": True,
-                        "boundary_note": "Execution boundary reached - timeout"
-                    }
-                    
-            except RuntimeError:
-                # No running loop, create one
-                logger.debug("🔄 Creating new event loop for async execution")
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                
-                try:
-                    result = loop.run_until_complete(asyncio.wait_for(coro, timeout=timeout))
-                    logger.debug(f"✅ Async execution completed in {time.time() - start_time:.2f}s")
-                    return result
-                except asyncio.TimeoutError:
-                    logger.error(f"❌ Async execution timed out after {timeout}s")
-                    return {
-                        "error": f"Async execution timed out after {timeout}s",
-                        "status": "failed",
-                        "timeout": True,
-                        "boundary_note": "Execution boundary reached - timeout"
-                    }
-                finally:
-                    # Clean up the loop
-                    if not loop.is_closed():
-                        loop.close()
-            
-        except Exception as e:
-            logger.error(f"❌ Async execution failed: {e}", exc_info=True)
-            return {
-                "error": str(e),
-                "status": "failed",
-                "execution_time": time.time() - start_time,
-                "boundary_note": "Execution boundary reached",
-                "error_type": type(e).__name__
-            }
-    
-    @staticmethod
-    def async_to_sync(async_func: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., Union[T, dict]]:
-        """
-        FIXED: Decorator to convert async function to sync with enhanced error handling
-        
-        Usage:
-            @AsyncRunner.async_to_sync
-            async def my_async_function():
-                ...
-                
-            # Can now be called synchronously
-            result = my_async_function()
-        """
-        @functools.wraps(async_func)
-        def wrapper(*args, **kwargs) -> Union[T, dict]:
-            try:
-                # Create the coroutine
-                coro = async_func(*args, **kwargs)
-                
-                # Run it with timeout
-                return AsyncRunner.run_async(coro)
-                
-            except Exception as e:
-                logger.error(f"❌ Async to sync conversion failed: {e}", exc_info=True)
-                return {
-                    "error": str(e),
-                    "status": "failed",
-                    "boundary_context": "OSS advisory only - execution requires Enterprise",
-                    "error_type": type(e).__name__
-                }
-        return wrapper
-    
-    @staticmethod
-    def is_async_context() -> bool:
-        """
-        Check if we're currently in an async context
-        
-        Returns:
-            True if in async context, False otherwise
-        """
-        try:
-            asyncio.get_running_loop()
-            return True
-        except RuntimeError:
-            return False
-
-# Convenience function for the decorator
-def async_to_sync(async_func: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., Union[T, dict]]:
-    """
-    Convenience decorator to convert async function to sync
-    
-    Usage:
-        @async_to_sync
-        async def my_async_function():
-            ...
-            
-        # Can now be called synchronously
-        result = my_async_function()
-    """
-    return AsyncRunner.async_to_sync(async_func)
-
-
-@contextmanager
-def safe_event_loop():
-    """
-    Context manager for safe event loop handling with cleanup
-    
-    Usage:
-        with safe_event_loop() as loop:
-            result = loop.run_until_complete(async_function())
-    """
-    loop = None
-    try:
-        # Try to get existing loop
-        try:
-            loop = asyncio.get_running_loop()
-            logger.debug("Using existing event loop")
-            yield loop
-            return
-        except RuntimeError:
-            pass
-        
-        # Create new loop
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        logger.debug("Created new event loop")
-        yield loop
-        
-    finally:
-        # Cleanup
-        if loop and not loop.is_closed():
-            loop.close()
-            logger.debug("Closed event loop")
-
-
-class AsyncCircuitBreaker:
-    """
-    Circuit breaker pattern for async operations to prevent cascading failures
-    """
-    
-    def __init__(self, failure_threshold: int = 5, recovery_timeout: float = 30.0):
-        self.failure_threshold = failure_threshold
-        self.recovery_timeout = recovery_timeout
-        self.failure_count = 0
-        self.last_failure_time = 0
-        self.state = "CLOSED"  # CLOSED, OPEN, HALF_OPEN
-        
-    def can_execute(self) -> bool:
-        """Check if circuit breaker allows execution"""
-        if self.state == "OPEN":
-            # Check if recovery timeout has passed
-            if time.time() - self.last_failure_time > self.recovery_timeout:
-                self.state = "HALF_OPEN"
-                logger.info("Circuit breaker moving to HALF_OPEN state")
-                return True
-            return False
-        return True
-    
-    def record_success(self):
-        """Record successful execution"""
-        if self.state == "HALF_OPEN":
-            self.state = "CLOSED"
-            logger.info("Circuit breaker reset to CLOSED state")
-        self.failure_count = 0
-    
-    def record_failure(self):
-        """Record failed execution"""
-        self.failure_count += 1
-        self.last_failure_time = time.time()
-        
-        if self.failure_count >= self.failure_threshold:
-            self.state = "OPEN"
-            logger.warning(f"Circuit breaker OPENED after {self.failure_count} failures")
-    
-    @AsyncRunner.async_to_sync
-    async def execute(self, coro: Coroutine) -> Any:
-        """Execute async operation with circuit breaker protection"""
-        if not self.can_execute():
-            raise Exception("Circuit breaker is OPEN - operation blocked")
-        
-        try:
-            result = await coro
-            self.record_success()
-            return result
-        except Exception as e:
-            self.record_failure()
-            raise e

utils/installation.py

@@ -1,195 +0,0 @@
-"""
-Installation helper utilities for ARF Demo - FIXED VERSION
-Updated to v3.3.9 (actual PyPI version) - SURGICAL FIX
-"""
-import subprocess
-import sys
-import logging
-from typing import Dict, Any, List, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class InstallationHelper:
-    """Helper class for ARF package installation - FIXED: No attempt to import non-existent packages"""
-    
-    @staticmethod
-    def install_arf_oss() -> Dict[str, Any]:
-        """Install ARF OSS package - FIXED: Updated to v3.3.9"""
-        try:
-            logger.info("Installing ARF OSS v3.3.9...")  # FIXED: v3.3.7 → v3.3.9
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "install", "agentic-reliability-framework==3.3.9"],  # FIXED: v3.3.9
-                capture_output=True,
-                text=True,
-                check=True
-            )
-            
-            return {
-                "success": True,
-                "message": "✅ ARF OSS v3.3.9 installed successfully",  # FIXED: v3.3.9
-                "output": result.stdout
-            }
-            
-        except subprocess.CalledProcessError as e:
-            return {
-                "success": False,
-                "message": "❌ Failed to install ARF OSS",
-                "error": e.stderr
-            }
-        except Exception as e:
-            return {
-                "success": False,
-                "message": f"❌ Installation error: {str(e)}",
-                "error": str(e)
-            }
-    
-    @staticmethod
-    def check_installation() -> Dict[str, Any]:
-        """
-        FIXED: Check ARF package installation - no attempt to import non-existent arf_enterprise
-        Enterprise is always simulated in this demo
-        """
-        try:
-            import agentic_reliability_framework as arf_oss
-            oss_version = getattr(arf_oss, '__version__', 'unknown')
-            oss_installed = True
-            logger.info(f"✅ ARF OSS v{oss_version} detected")
-        except ImportError:
-            oss_installed = False
-            oss_version = None
-            logger.info("⚠️ ARF OSS not installed - using mock mode")
-        
-        # FIXED: Enterprise is ALWAYS simulated - package doesn't exist
-        enterprise_installed = False
-        enterprise_version = "simulated"
-        logger.info("⚠️ ARF Enterprise not installed - using simulation")
-        
-        return {
-            "oss_installed": oss_installed,
-            "oss_version": oss_version,
-            "enterprise_installed": enterprise_installed,  # Always false
-            "enterprise_version": enterprise_version,  # Always "simulated"
-            "recommendations": InstallationHelper.get_recommendations(oss_installed, enterprise_installed),
-            "boundaries": {
-                "oss_can": ["advisory_analysis", "rag_search", "healing_intent"],
-                "oss_cannot": ["execute", "modify_infra", "autonomous_healing"],
-                "enterprise_simulated": True,
-                "enterprise_requires_license": True,
-                "architecture": "OSS advises → Enterprise simulates"
-            }
-        }
-    
-    @staticmethod
-    def get_recommendations(oss_installed: bool, enterprise_installed: bool) -> List[str]:
-        """
-        FIXED: Get realistic installation recommendations
-        Enterprise package doesn't exist publicly
-        """
-        recommendations = []
-        
-        if not oss_installed:
-            recommendations.append(
-                "Install ARF OSS: `pip install agentic-reliability-framework==3.3.9`"  # FIXED: v3.3.9
-            )
-            recommendations.append(
-                "💡 Without OSS, demo runs in mock mode with simulated analysis"
-            )
-        
-        # FIXED: Enterprise is simulated, not installable
-        recommendations.append(
-            "🔒 ARF Enterprise requires commercial license - simulated in this demo"
-        )
-        recommendations.append(
-            "🏢 Contact sales@arf.dev for Enterprise trial access"
-        )
-        
-        return recommendations
-    
-    @staticmethod
-    def get_installation_html() -> str:
-        """Get HTML for installation status display - FIXED to show clear boundaries"""
-        status = InstallationHelper.check_installation()
-        
-        if status["oss_installed"]:
-            oss_html = f"""
-            <div style="padding: 10px; background: linear-gradient(135deg, #10b981 0%, #0ca678 100%); 
-                       color: white; border-radius: 8px; margin: 5px 0; border: 1px solid #0da271;">
-                <div style="display: flex; align-items: center; gap: 8px;">
-                    <span style="font-size: 16px;">✅</span>
-                    <div>
-                        <div style="font-weight: 600;">ARF OSS v{status['oss_version']}</div>
-                        <div style="font-size: 12px; opacity: 0.9;">Apache 2.0 • Advisory Intelligence</div>
-                    </div>
-                </div>
-            </div>
-            """
-        else:
-            oss_html = """
-            <div style="padding: 10px; background: linear-gradient(135deg, #f59e0b 0%, #e0950a 100%); 
-                       color: white; border-radius: 8px; margin: 5px 0; border: 1px solid #d98a09;">
-                <div style="display: flex; align-items: center; gap: 8px;">
-                    <span style="font-size: 16px;">⚠️</span>
-                    <div>
-                        <div style="font-weight: 600;">Mock ARF</div>
-                        <div style="font-size: 12px; opacity: 0.9;">Simulated analysis only</div>
-                    </div>
-                </div>
-            </div>
-            """
-        
-        # FIXED: Enterprise is always simulated
-        enterprise_html = f"""
-        <div style="padding: 10px; background: linear-gradient(135deg, #64748b 0%, #4b5563 100%); 
-                   color: white; border-radius: 8px; margin: 5px 0; border: 1px dashed #9ca3af;">
-            <div style="display: flex; align-items: center; gap: 8px;">
-                <span style="font-size: 16px;">🔒</span>
-                <div>
-                    <div style="font-weight: 600;">Enterprise Simulation</div>
-                    <div style="font-size: 12px; opacity: 0.9;">v{status['enterprise_version']} • Commercial License Required</div>
-                </div>
-            </div>
-        </div>
-        """
-        
-        # FIXED: Realistic recommendations
-        recommendations_html = ""
-        if status["recommendations"]:
-            rec_list = "\n".join([f"<li style='margin-bottom: 5px;'>{rec}</li>" for rec in status["recommendations"][:3]])
-            recommendations_html = f"""
-            <div style="margin-top: 15px; padding: 12px; background: #f8fafc; border-radius: 8px; border: 1px solid #e2e8f0;">
-                <div style="font-weight: 600; color: #475569; margin-bottom: 8px; display: flex; align-items: center; gap: 6px;">
-                    <span>💡</span> <span>Architecture & Recommendations</span>
-                </div>
-                <ul style="margin: 5px 0 0 0; padding-left: 20px; color: #64748b; font-size: 13px;">
-                    {rec_list}
-                </ul>
-            </div>
-            """
-        
-        # FIXED: Add boundary context
-        boundary_html = """
-        <div style="margin-top: 10px; padding: 8px; background: #f0fdf4; border-radius: 6px; border: 1px solid #d1fae5;">
-            <div style="font-size: 12px; color: #059669; display: flex; align-items: center; gap: 6px;">
-                <span style="display: inline-block; width: 8px; height: 8px; background: #10b981; border-radius: 50%;"></span>
-                <span>Boundary: OSS advises → Enterprise simulates</span>
-            </div>
-        </div>
-        """
-        
-        return f"""
-        <div style="border: 2px solid #e2e8f0; border-radius: 12px; padding: 15px; background: white; 
-                   box-shadow: 0 1px 3px rgba(0,0,0,0.05);">
-            <h4 style="margin: 0 0 12px 0; color: #1e293b; font-size: 16px; font-weight: 600;">
-                📦 ARF Installation & Boundaries
-            </h4>
-            {oss_html}
-            {enterprise_html}
-            {boundary_html}
-            {recommendations_html}
-        </div>
-        """
-
-
-# Export singleton
-installation_helper = InstallationHelper()