pos nomas

yuubox/executor.py

@@ -0,0 +1,128 @@
+import time
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+try:
+    from yuubox.yuubox_core import ContainerExecutor as RustExecutor
+except ImportError:
+    RustExecutor = None
+
+from yuubox.analyzer import ErrorAnalyzer
+from yuubox.healer import YuukiHealer
+from yuubox.exceptions import ExecutionError
+
+@dataclass
+class ResourceLimits:
+    memory_mb: int = 256
+    cpu_quota: float = 1.0
+    timeout_seconds: int = 60
+
+@dataclass
+class ErrorReport:
+    error_type: str
+    error_message: str
+    iteration: int
+    line_number: Optional[int] = None
+
+@dataclass
+class ExecutionResult:
+    success: bool
+    stdout: str
+    stderr: str
+    exit_code: int
+    iterations: int
+    execution_time: float
+    final_code: str
+    error_history: List[ErrorReport] = field(default_factory=list)
+
+class YuuBox:
+    """Self-healing code executor (Rust + Python hybrid)"""
+    
+    def __init__(self, max_iterations: int = 5, yuuki_api_url: Optional[str] = None):
+        if RustExecutor is None:
+            raise ImportError("Rust core not compiled. Run: maturin develop")
+        
+        self.max_iterations = max_iterations
+        self.rust_executor = RustExecutor()
+        self.analyzer = ErrorAnalyzer()
+        self.healer = YuukiHealer(yuuki_api_url)
+    
+    def execute(
+        self,
+        code: str,
+        language: str,
+        limits: Optional[ResourceLimits] = None,
+        no_healing: bool = False,
+    ) -> ExecutionResult:
+        limits = limits or ResourceLimits()
+        current_code = code
+        error_history = []
+        start_time = time.time()
+        
+        for iteration in range(1, self.max_iterations + 1):
+            # Execute in Rust (FAST!)
+            result = self.rust_executor.execute(
+                current_code,
+                language,
+                limits.memory_mb,
+                limits.cpu_quota,
+                limits.timeout_seconds,
+            )
+            
+            if result.exit_code == 0:
+                return ExecutionResult(
+                    success=True,
+                    stdout=result.stdout,
+                    stderr=result.stderr,
+                    exit_code=0,
+                    iterations=iteration,
+                    execution_time=time.time() - start_time,
+                    final_code=current_code,
+                    error_history=error_history,
+                )
+            
+            if no_healing:
+                return ExecutionResult(
+                    success=False,
+                    stdout=result.stdout,
+                    stderr=result.stderr,
+                    exit_code=result.exit_code,
+                    iterations=1,
+                    execution_time=time.time() - start_time,
+                    final_code=current_code,
+                    error_history=error_history,
+                )
+            
+            # Analyze error (Python)
+            error = self.analyzer.analyze(result.stderr, language, current_code)
+            error_report = ErrorReport(
+                error_type=error["type"],
+                error_message=error["message"],
+                iteration=iteration,
+                line_number=error.get("line"),
+            )
+            error_history.append(error_report)
+            
+            # Heal with Yuuki (Python)
+            try:
+                fixed_code = self.healer.fix(current_code, error, language, error_history)
+                if not fixed_code or fixed_code == current_code:
+                    break
+                current_code = fixed_code
+            except Exception as e:
+                break
+        
+        return ExecutionResult(
+            success=False,
+            stdout=result.stdout,
+            stderr=result.stderr,
+            exit_code=result.exit_code,
+            iterations=iteration,
+            execution_time=time.time() - start_time,
+            final_code=current_code,
+            error_history=error_history,
+        )
+    
+    def cleanup(self):
+        """Cleanup resources"""
+        self.rust_executor.cleanup()