jarviscore-framework 0.1.0__py3-none-any.whl

jarviscore/execution/repair.py

@@ -0,0 +1,283 @@
+"""
+Autonomous Repair - LLM-based automatic code fixing
+Analyzes errors and generates corrected code
+"""
+import ast
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AutonomousRepair:
+    """
+    Automatic code repair using LLM.
+
+    Philosophy:
+    - Code execution fails → analyze error
+    - LLM generates fixed version
+    - Validate and retry (max 3 attempts)
+    - Learn from previous failures
+
+    Example:
+        repair = AutonomousRepair(code_generator)
+        fixed_code = await repair.repair(
+            original_code="result = 1/0",
+            error=ZeroDivisionError("division by zero"),
+            task={"task": "Calculate result"}
+        )
+    """
+
+    def __init__(self, code_generator, max_attempts: int = 3):
+        """
+        Initialize repair system.
+
+        Args:
+            code_generator: CodeGenerator instance
+            max_attempts: Maximum repair attempts (default 3)
+        """
+        self.codegen = code_generator
+        self.max_attempts = max_attempts
+
+        self.repair_template = self._load_repair_template()
+
+    def _load_repair_template(self) -> str:
+        """Load prompt template for code repair."""
+        return """You are an expert Python debugger. The following code FAILED during execution.
+
+ORIGINAL CODE:
+```python
+{original_code}
+```
+
+ERROR DETAILS:
+Type: {error_type}
+Message: {error_message}
+
+ORIGINAL TASK:
+{task}
+
+{previous_attempts}
+
+INSTRUCTIONS:
+1. Analyze the error carefully
+2. Identify the root cause (syntax error, logic error, missing import, etc.)
+3. Generate FIXED Python code that:
+   - Solves the original task
+   - Handles the error properly
+   - Stores result in 'result' variable
+   - Is complete and executable
+
+CRITICAL:
+- Write ONLY executable Python code (no explanations)
+- DO NOT repeat the same mistake
+- Add proper error handling (try/except)
+- Test edge cases in your mind
+
+Generate the FIXED code now (code only):
+"""
+
+    async def repair(
+        self,
+        code: str,
+        error: Exception,
+        task: Dict[str, Any],
+        system_prompt: str,
+        attempt: int = 1,
+        previous_attempts: Optional[list] = None
+    ) -> str:
+        """
+        Repair failed code using LLM.
+
+        Args:
+            code: Original code that failed
+            error: Exception that occurred
+            task: Original task specification
+            system_prompt: Agent's system prompt
+            attempt: Current repair attempt number (1-3)
+            previous_attempts: List of previous failed attempts
+
+        Returns:
+            Fixed Python code
+
+        Raises:
+            RuntimeError: If max attempts exceeded
+            ValueError: If fixed code has syntax errors
+
+        Example:
+            try:
+                result = await executor.execute(code)
+            except Exception as e:
+                fixed_code = await repair.repair(code, e, task, system_prompt)
+                result = await executor.execute(fixed_code)
+        """
+        if attempt > self.max_attempts:
+            raise RuntimeError(
+                f"Repair failed after {self.max_attempts} attempts. "
+                f"Last error: {error}"
+            )
+
+        logger.info(f"Attempting code repair (attempt {attempt}/{self.max_attempts})")
+        logger.debug(f"Error: {type(error).__name__}: {error}")
+
+        # Format previous attempts info
+        attempts_info = ""
+        if previous_attempts:
+            attempts_info = "PREVIOUS FAILED ATTEMPTS:\n"
+            for i, prev in enumerate(previous_attempts, 1):
+                attempts_info += f"\nAttempt {i}:\n"
+                attempts_info += f"Error: {prev['error']}\n"
+                attempts_info += f"Code:\n```python\n{prev['code']}\n```\n"
+
+        # Build repair prompt
+        prompt = self.repair_template.format(
+            original_code=code,
+            error_type=type(error).__name__,
+            error_message=str(error),
+            task=task.get('task', ''),
+            previous_attempts=attempts_info
+        )
+
+        # Add system context
+        prompt = f"{system_prompt}\n\n{prompt}"
+
+        try:
+            # Generate fixed code via LLM
+            response = await self.codegen.llm.generate(
+                prompt=prompt,
+                temperature=0.4,  # Slightly higher for creative problem solving
+                max_tokens=4000
+            )
+
+            fixed_code = response['content']
+
+            # Clean up code
+            fixed_code = self.codegen._clean_code(fixed_code)
+
+            # Validate syntax
+            self._validate_fix(fixed_code)
+
+            logger.info(f"Code repair attempt {attempt} successful")
+            return fixed_code
+
+        except Exception as e:
+            logger.error(f"Repair attempt {attempt} failed: {e}")
+            raise RuntimeError(f"Failed to repair code: {e}")
+
+    def _validate_fix(self, code: str):
+        """
+        Validate that fixed code has correct syntax.
+
+        Args:
+            code: Fixed Python code
+
+        Raises:
+            ValueError: If code has syntax errors
+        """
+        try:
+            ast.parse(code)
+            logger.debug("Fixed code syntax validation passed")
+        except SyntaxError as e:
+            logger.error(f"Fixed code still has syntax errors: {e}")
+            raise ValueError(f"Repaired code has syntax errors: {e}")
+
+    async def repair_with_retries(
+        self,
+        code: str,
+        error: Exception,
+        task: Dict[str, Any],
+        system_prompt: str,
+        executor
+    ) -> Dict[str, Any]:
+        """
+        Repair code with automatic retry on failure.
+
+        This is a high-level method that:
+        1. Attempts repair
+        2. Executes fixed code
+        3. If still fails, tries again (up to max_attempts)
+
+        Args:
+            code: Original failed code
+            error: Exception from execution
+            task: Task specification
+            system_prompt: Agent system prompt
+            executor: SandboxExecutor instance for testing fixes
+
+        Returns:
+            Final execution result (success or failure)
+
+        Example:
+            result = await repair.repair_with_retries(
+                code, error, task, system_prompt, executor
+            )
+        """
+        previous_attempts = []
+        current_code = code
+        current_error = error
+
+        for attempt in range(1, self.max_attempts + 1):
+            try:
+                # Track this attempt
+                previous_attempts.append({
+                    'code': current_code,
+                    'error': str(current_error)
+                })
+
+                # Generate fix
+                fixed_code = await self.repair(
+                    code=current_code,
+                    error=current_error,
+                    task=task,
+                    system_prompt=system_prompt,
+                    attempt=attempt,
+                    previous_attempts=previous_attempts if attempt > 1 else None
+                )
+
+                # Test the fix
+                logger.info(f"Testing repair attempt {attempt}...")
+                result = await executor.execute(fixed_code)
+
+                if result['status'] == 'success':
+                    logger.info(f"✓ Repair succeeded on attempt {attempt}")
+                    return result
+                else:
+                    # Fix didn't work, prepare for next attempt
+                    current_code = fixed_code
+                    current_error = Exception(result.get('error', 'Unknown error'))
+                    logger.warning(
+                        f"Repair attempt {attempt} executed but failed: "
+                        f"{result.get('error')}"
+                    )
+
+            except Exception as e:
+                logger.error(f"Repair attempt {attempt} failed with exception: {e}")
+                current_error = e
+                if attempt == self.max_attempts:
+                    # Last attempt failed
+                    return {
+                        'status': 'failure',
+                        'error': f'All {self.max_attempts} repair attempts exhausted',
+                        'last_error': str(e)
+                    }
+
+        # Should not reach here, but just in case
+        return {
+            'status': 'failure',
+            'error': f'Repair failed after {self.max_attempts} attempts',
+            'attempts': previous_attempts
+        }
+
+
+def create_autonomous_repair(code_generator, max_attempts: int = 3) -> AutonomousRepair:
+    """
+    Factory function to create autonomous repair system.
+
+    Args:
+        code_generator: CodeGenerator instance
+        max_attempts: Max repair attempts (default 3)
+
+    Returns:
+        AutonomousRepair instance
+    """
+    return AutonomousRepair(code_generator, max_attempts)

jarviscore/execution/result_handler.py

@@ -0,0 +1,332 @@
+"""
+Result Handler - Process and store function execution results
+Storage: File system + In-memory (no external dependencies)
+"""
+import json
+import logging
+import os
+import time
+import datetime
+from typing import Dict, Any, Optional
+from enum import Enum
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class ResultStatus(Enum):
+    """Execution result status."""
+    SUCCESS = "success"
+    FAILURE = "failure"
+    SYNTAX_ERROR = "syntax_error"
+    RUNTIME_ERROR = "runtime_error"
+    TIMEOUT = "timeout"
+    PARTIAL = "partial"
+
+
+class ErrorCategory(Enum):
+    """Error classification categories."""
+    SYNTAX = "syntax"
+    RUNTIME = "runtime"
+    NETWORK = "network"
+    TIMEOUT = "timeout"
+    RESOURCE = "resource"
+    UNKNOWN = "unknown"
+
+
+class ResultHandler:
+    """
+    Handles processing, formatting, and storage of execution results.
+
+    Storage:
+    - File system: ./logs/{agent_id}/{result_id}.json
+    - In-memory: LRU cache for fast access
+
+    Features:
+    - Stores generated code with results
+    - Sanitizes sensitive parameters
+    - Classifies errors automatically
+    - Provides retrieval by result_id
+
+    Zero-config: No external dependencies (no Redis, no DB)
+    """
+
+    def __init__(self, log_directory: str = "./logs", max_cache_size: int = 100):
+        """
+        Initialize result handler.
+
+        Args:
+            log_directory: Base directory for storing results
+            max_cache_size: Maximum number of results to cache in memory
+        """
+        self.log_directory = Path(log_directory)
+        self.log_directory.mkdir(parents=True, exist_ok=True)
+
+        # In-memory cache (LRU)
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self._cache_order = []  # For LRU eviction
+        self.max_cache_size = max_cache_size
+
+        logger.info(f"ResultHandler initialized with directory: {self.log_directory}")
+
+    def process_result(
+        self,
+        agent_id: str,
+        task: str,
+        code: str,
+        output: Any,
+        status: str,
+        error: Optional[str] = None,
+        execution_time: Optional[float] = None,
+        tokens: Optional[Dict] = None,
+        cost_usd: Optional[float] = None,
+        repairs: int = 0,
+        metadata: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """
+        Process and store execution result.
+
+        Args:
+            agent_id: ID of the agent that executed
+            task: Original task description
+            code: Generated code that was executed
+            output: Execution output (result variable)
+            status: "success" or "failure"
+            error: Error message if failed
+            execution_time: Time taken in seconds
+            tokens: Token usage {input, output, total}
+            cost_usd: Estimated cost
+            repairs: Number of repair attempts
+            metadata: Additional metadata
+
+        Returns:
+            Processed result dictionary with storage metadata
+        """
+        timestamp = datetime.datetime.now().isoformat()
+        result_id = self._generate_result_id(agent_id, timestamp)
+
+        # Classify error if present
+        error_category = None
+        if error:
+            error_category = self._classify_error(error)
+
+        # Determine detailed status
+        result_status = self._determine_status(status, error, error_category)
+
+        # Build result object
+        result_data = {
+            # Identity
+            "result_id": result_id,
+            "agent_id": agent_id,
+            "timestamp": timestamp,
+
+            # Execution details
+            "task": task,
+            "code": code,
+            "output": output,
+
+            # Status
+            "status": result_status.value,
+            "success": result_status == ResultStatus.SUCCESS,
+
+            # Error details
+            "error": error,
+            "error_category": error_category.value if error_category else None,
+
+            # Metrics
+            "execution_time": execution_time,
+            "tokens": tokens or {},
+            "cost_usd": cost_usd or 0.0,
+            "repairs": repairs,
+
+            # Metadata
+            "metadata": metadata or {}
+        }
+
+        # Store to file system
+        self._save_to_file(agent_id, result_id, result_data)
+
+        # Store in memory cache
+        self._cache_result(result_id, result_data)
+
+        # Log summary
+        if result_status == ResultStatus.SUCCESS:
+            time_str = f"{execution_time:.2f}s" if execution_time else "N/A"
+            logger.info(
+                f"Result {result_id}: SUCCESS in {time_str} "
+                f"(repairs: {repairs}, cost: ${cost_usd:.4f})"
+            )
+        else:
+            logger.error(
+                f"Result {result_id}: {result_status.value} - {error}"
+            )
+
+        return result_data
+
+    def get_result(self, result_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve result by ID (checks cache first, then file system).
+
+        Args:
+            result_id: Result identifier
+
+        Returns:
+            Result dictionary or None if not found
+        """
+        # Check in-memory cache first
+        if result_id in self._cache:
+            logger.debug(f"Result {result_id} retrieved from cache")
+            return self._cache[result_id]
+
+        # Search file system
+        result_data = self._load_from_file(result_id)
+        if result_data:
+            # Cache for future access
+            self._cache_result(result_id, result_data)
+            logger.debug(f"Result {result_id} loaded from file")
+            return result_data
+
+        logger.warning(f"Result {result_id} not found")
+        return None
+
+    def get_agent_results(self, agent_id: str, limit: int = 10) -> list:
+        """
+        Get recent results for a specific agent.
+
+        Args:
+            agent_id: Agent identifier
+            limit: Maximum number of results to return
+
+        Returns:
+            List of result dictionaries, most recent first
+        """
+        agent_dir = self.log_directory / agent_id
+        if not agent_dir.exists():
+            return []
+
+        # Get all result files for this agent
+        result_files = sorted(
+            agent_dir.glob("*.json"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True
+        )[:limit]
+
+        results = []
+        for result_file in result_files:
+            try:
+                with open(result_file, 'r') as f:
+                    results.append(json.load(f))
+            except Exception as e:
+                logger.warning(f"Failed to load {result_file}: {e}")
+
+        return results
+
+    def _generate_result_id(self, agent_id: str, timestamp: str) -> str:
+        """Generate unique result ID."""
+        clean_timestamp = timestamp.replace(':', '-').replace('.', '_')
+        return f"{agent_id}_{clean_timestamp}"
+
+    def _determine_status(
+        self,
+        status: str,
+        error: Optional[str],
+        error_category: Optional[ErrorCategory]
+    ) -> ResultStatus:
+        """Determine detailed result status."""
+        if status == "success":
+            return ResultStatus.SUCCESS
+
+        if error_category == ErrorCategory.SYNTAX:
+            return ResultStatus.SYNTAX_ERROR
+        elif error_category == ErrorCategory.TIMEOUT:
+            return ResultStatus.TIMEOUT
+        elif error and "error" in error.lower():
+            return ResultStatus.RUNTIME_ERROR
+
+        return ResultStatus.FAILURE
+
+    def _classify_error(self, error: str) -> ErrorCategory:
+        """Classify error into category."""
+        error_lower = error.lower()
+
+        # Syntax errors
+        syntax_keywords = ['syntaxerror', 'indentationerror', 'taberror', 'invalid syntax']
+        if any(kw in error_lower for kw in syntax_keywords):
+            return ErrorCategory.SYNTAX
+
+        # Timeout errors
+        timeout_keywords = ['timeout', 'timed out', 'time limit exceeded']
+        if any(kw in error_lower for kw in timeout_keywords):
+            return ErrorCategory.TIMEOUT
+
+        # Network errors
+        network_keywords = ['connection', 'network', 'httpx', 'aiohttp', 'socket']
+        if any(kw in error_lower for kw in network_keywords):
+            return ErrorCategory.NETWORK
+
+        # Resource errors
+        resource_keywords = ['memory', 'resource', 'quota', 'limit exceeded']
+        if any(kw in error_lower for kw in resource_keywords):
+            return ErrorCategory.RESOURCE
+
+        # Runtime errors (default for unknown errors)
+        return ErrorCategory.RUNTIME
+
+    def _save_to_file(self, agent_id: str, result_id: str, result_data: Dict):
+        """Save result to file system."""
+        agent_dir = self.log_directory / agent_id
+        agent_dir.mkdir(parents=True, exist_ok=True)
+
+        result_file = agent_dir / f"{result_id}.json"
+
+        try:
+            with open(result_file, 'w') as f:
+                json.dump(result_data, f, indent=2, default=str)
+            logger.debug(f"Saved result to {result_file}")
+        except Exception as e:
+            logger.error(f"Failed to save result to file: {e}")
+
+    def _load_from_file(self, result_id: str) -> Optional[Dict]:
+        """Load result from file system by searching all agent directories."""
+        for agent_dir in self.log_directory.iterdir():
+            if not agent_dir.is_dir():
+                continue
+
+            result_file = agent_dir / f"{result_id}.json"
+            if result_file.exists():
+                try:
+                    with open(result_file, 'r') as f:
+                        return json.load(f)
+                except Exception as e:
+                    logger.warning(f"Failed to load {result_file}: {e}")
+
+        return None
+
+    def _cache_result(self, result_id: str, result_data: Dict):
+        """Cache result in memory with LRU eviction."""
+        # Add to cache
+        self._cache[result_id] = result_data
+
+        # Track access order
+        if result_id in self._cache_order:
+            self._cache_order.remove(result_id)
+        self._cache_order.append(result_id)
+
+        # Evict oldest if cache is full
+        while len(self._cache) > self.max_cache_size:
+            oldest_id = self._cache_order.pop(0)
+            del self._cache[oldest_id]
+            logger.debug(f"Evicted {oldest_id} from cache (LRU)")
+
+
+def create_result_handler(log_directory: str = "./logs") -> ResultHandler:
+    """
+    Factory function to create result handler.
+
+    Args:
+        log_directory: Base directory for result storage
+
+    Returns:
+        ResultHandler instance
+    """
+    return ResultHandler(log_directory)