healing-agent 0.2.4__py3-none-any.whl

healing_agent/__init__.py

@@ -0,0 +1,15 @@
+from .healing_agent import healing_agent as _healing_agent
+
+# Make the module callable by implementing __call__
+class HealingAgentModule:
+    def __init__(self):
+        self.healing_agent = _healing_agent
+    
+    def __call__(self, *args, **kwargs):
+        return self.healing_agent(*args, **kwargs)
+
+# Replace the module with our callable instance
+import sys
+sys.modules[__name__] = HealingAgentModule()
+
+__all__ = ['healing_agent']

healing_agent/agent_tools/tool_check_env_variables.py

@@ -0,0 +1,19 @@
+# Experimental and not used.
+
+import os
+
+def get_environment_variables() -> dict:
+    """
+    Get all environment variables and return them as a dictionary.
+    
+    Returns:
+        dict: Dictionary containing all environment variables as key-value pairs
+    """
+    env_vars = {}
+    for key, value in os.environ.items():
+        env_vars[key] = value
+    return env_vars
+
+if __name__ == "__main__":
+    print(get_environment_variables())
+

healing_agent/agent_tools/tool_json_fixer.py

@@ -0,0 +1,80 @@
+# Experimental and not used.
+
+import json
+from typing import Any, Dict
+from ..ai_code_fixer import get_ai_response
+
+def fix_json_ai(context: Dict[str, Any], config: Dict[str, Any]) -> Any:
+    """
+    Attempt to fix JSON data using AI.
+    """
+    try:
+        json_data = context['error']['json_details']['response_text']
+        
+        # Extract the first 1000 characters of the JSON data
+        json_snippet = json_data[:1000]
+        
+        # Prepare the prompt for AI
+        prompt = f"""
+Fix the following JSON data:
+
+{json_snippet}
+
+Return only the fixed JSON data without any explanations or markdown formatting.
+"""
+        
+        # Get the fix from AI
+        fixed_json_str = get_ai_response(prompt, config)
+        
+        # Parse the fixed JSON string
+        fixed_data = json.loads(fixed_json_str)
+        
+        return fixed_data
+    except Exception as e:
+        print(f"♣ JSON fixing with AI failed: {str(e)}")
+        return None
+
+def fix_json_lint(context: Dict[str, Any], config: Dict[str, Any]) -> Any:
+    """
+    Attempt to fix JSON data using a JSON linter.
+    """
+    try:
+        json_data = context['error']['json_details']['response_text']
+        # Use a JSON linter library to identify and fix syntax errors
+        # Example using jsonlint:
+        # fixed_data = jsonlint.parse(json_data)
+        # return fixed_data
+        pass
+    except Exception as e:
+        print(f"♣ JSON linting failed: {str(e)}")
+        return None
+
+def fix_json_fallback(context: Dict[str, Any], config: Dict[str, Any]) -> Any:
+    """
+    Attempt to fix JSON data using fallback parsing options.
+    """
+    try:
+        json_data = context['error']['json_details']['response_text']
+        # Use fallback parsing options, e.g., allow trailing commas
+        fixed_data = json.loads(json_data, strict=False)
+        return fixed_data
+    except json.JSONDecodeError as e:
+        print(f"♣ Fallback JSON parsing failed: {str(e)}")
+        return None
+
+def fix_json(context: Dict[str, Any], config: Dict[str, Any]) -> Any:
+    """
+    Attempt to fix JSON data using the selected strategy.
+    """
+    strategy = config.get('JSON_FIX_STRATEGY', 'ai')
+
+    if strategy == 'ai':
+        return fix_json_ai(context, config)
+    elif strategy == 'lint':
+        return fix_json_lint(context, config)
+    elif strategy == 'fallback':
+        return fix_json_fallback(context, config)
+    else:
+        print(f"♣ Unknown JSON fix strategy: {strategy}")
+        return None
+

healing_agent/agent_tools/tool_list_files_functions.py

@@ -0,0 +1,116 @@
+# Experimental and not used.
+
+import os
+import ast
+import json
+from typing import Dict, List, Optional, Union
+
+def get_function_details(file_path: str) -> List[Dict[str, str]]:
+    """
+    Extract function names and docstrings from a Python file.
+    
+    Args:
+        file_path: Path to the Python file
+        
+    Returns:
+        List of dictionaries containing function names and their docstrings
+    """
+    functions = []
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            tree = ast.parse(f.read())
+            
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef):
+                docstring = ast.get_docstring(node)
+                functions.append({
+                    "name": node.name,
+                    "docstring": docstring if docstring else "No description available"
+                })
+    except Exception as e:
+        print(f"Error parsing {file_path}: {str(e)}")
+        return []
+        
+    return functions
+
+def list_directory_contents(
+    directory: str,
+    recursive: bool = False,
+    include_functions: bool = False
+) -> Dict[str, Union[List[str], Dict[str, List[Dict[str, str]]]]]:
+    """
+    List all files in a directory with optional recursive search and Python function details.
+    
+    Args:
+        directory: Path to the directory to scan
+        recursive: Whether to scan subdirectories recursively
+        include_functions: Whether to extract function details from Python files
+        
+    Returns:
+        Dictionary containing:
+            - files: List of all files
+            - python_files: Dictionary of Python files and their function details (if include_functions=True)
+    """
+    
+    if not os.path.exists(directory):
+        raise ValueError(f"Directory {directory} does not exist")
+        
+    result = {
+        "files": [],
+        "python_files": {}
+    }
+    
+    def scan_directory(path: str):
+        for entry in os.scandir(path):
+            if entry.is_file():
+                file_path = os.path.relpath(entry.path, directory)
+                result["files"].append(file_path)
+                
+                if include_functions and file_path.endswith('.py'):
+                    functions = get_function_details(entry.path)
+                    if functions:
+                        result["python_files"][file_path] = functions
+                        
+            elif entry.is_dir() and recursive:
+                scan_directory(entry.path)
+                
+    scan_directory(directory)
+    
+    # Sort files for consistent output
+    result["files"].sort()
+    
+    return result
+
+def get_directory_info(
+    directory: str = ".",
+    recursive: bool = False,
+    include_functions: bool = False,
+    pretty_print: bool = False
+) -> str:
+    """
+    Get directory information in JSON format.
+    
+    Args:
+        directory: Path to the directory to scan (defaults to current directory)
+        recursive: Whether to scan subdirectories recursively
+        include_functions: Whether to extract function details from Python files
+        pretty_print: Whether to format the JSON output with indentation
+        
+    Returns:
+        JSON string containing directory information
+    """
+    try:
+        contents = list_directory_contents(
+            directory,
+            recursive=recursive,
+            include_functions=include_functions
+        )
+        
+        return json.dumps(contents, indent=2 if pretty_print else None)
+        
+    except Exception as e:
+        error_response = {
+            "error": str(e),
+            "directory": directory
+        }
+        return json.dumps(error_response, indent=2 if pretty_print else None)

healing_agent/ai_broker.py

@@ -0,0 +1,202 @@
+from typing import Dict
+import time
+import httpx
+import requests
+import openai
+from functools import wraps
+
+def handle_connection_errors(provider_name: str):
+    """Simple decorator to handle connection errors with basic logging"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except (
+                httpx.ConnectError,
+                requests.exceptions.ConnectionError,
+                requests.exceptions.Timeout,
+                ConnectionError,
+                TimeoutError
+            ) as e:
+                print(f"♣ Connection error in {provider_name}: {str(e)}")
+                # Wait briefly before retrying
+                time.sleep(2)
+                try:
+                    return func(*args, **kwargs)
+                except Exception as retry_error:
+                    print(f"♣ Retry failed for {provider_name}: {str(retry_error)}")
+                    raise
+            except openai.APIConnectionError as e:
+                if 'OpenAI' in provider_name or 'Azure' in provider_name:
+                    print(f"♣ Connection error in {provider_name}: {str(e)}")
+                    # Wait briefly before retrying
+                    time.sleep(2)
+                    try:
+                        return func(*args, **kwargs)
+                    except Exception as retry_error:
+                        print(f"♣ Retry failed for {provider_name}: {str(retry_error)}")
+                        raise
+                else:
+                    raise
+            except Exception as e:
+                print(f"♣ Unexpected error in {provider_name}: {str(e)}")
+                raise
+        return wrapper
+    return decorator
+
+@handle_connection_errors("Azure")
+def _get_azure_response(prompt: str, config: Dict, system_prompt: str) -> str:
+    """Handle Azure OpenAI API requests"""
+    import openai
+    client = openai.AzureOpenAI(
+        api_key=config['api_key'],
+        api_version=config['api_version'],
+        azure_endpoint=config['endpoint']
+    )
+    
+    try:
+        response = client.chat.completions.create(
+            model=config['deployment_name'],
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            timeout=config.get('timeout', 30)
+        )
+        return response.choices[0].message.content.strip()
+    except openai.APIError as e:
+        print(f"♣ Azure API error: {str(e)}")
+        raise
+
+@handle_connection_errors("OpenAI")
+def _get_openai_response(prompt: str, config: Dict, system_prompt: str) -> str:
+    """Handle OpenAI direct API requests"""
+    import openai
+    client = openai.OpenAI(
+        api_key=config['api_key'],
+        organization=config.get('organization_id')
+    )
+    
+    try:
+        response = client.chat.completions.create(
+            model=config['model'],
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            timeout=config.get('timeout', 30)
+        )
+        return response.choices[0].message.content.strip()
+    except openai.APIError as e:
+        print(f"♣ OpenAI API error: {str(e)}")
+        raise
+
+@handle_connection_errors("Anthropic")
+def _get_anthropic_response(prompt: str, config: Dict) -> str:
+    """Handle Anthropic API requests"""
+    import anthropic
+    client = anthropic.Anthropic(api_key=config['api_key'])
+    
+    try:
+        response = client.messages.create(
+            model=config['model'],
+            max_tokens=1000,
+            messages=[{
+                "role": "user",
+                "content": prompt
+            }],
+            timeout=config.get('timeout', 30)
+        )
+        return response.content[0].text
+    except Exception as e:
+        print(f"♣ Anthropic API error: {str(e)}")
+        raise
+
+@handle_connection_errors("Ollama")
+def _get_ollama_response(prompt: str, config: Dict) -> str:
+    """Handle Ollama API requests"""
+    try:
+        response = requests.post(
+            f"{config['host']}/api/generate",
+            json={
+                "model": config['model'],
+                "prompt": prompt,
+                "stream": False
+            },
+            timeout=config.get('timeout', 120)
+        )
+        response.raise_for_status()
+        return response.json()['response']
+    except requests.exceptions.RequestException as e:
+        print(f"♣ Ollama API error: {str(e)}")
+        raise
+
+@handle_connection_errors("LiteLLM")
+def _get_litellm_response(prompt: str, config: Dict, system_prompt: str) -> str:
+    """Handle LiteLLM API requests"""
+    import litellm
+    if config.get('api_base'):
+        litellm.api_base = config['api_base']
+    
+    try:
+        response = litellm.completion(
+            model=config['model'],
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            api_key=config['api_key'],
+            timeout=config.get('timeout', 30)
+        )
+        if not response or not response.choices:
+            raise ValueError("Invalid response from LiteLLM API - no choices returned")
+            
+        if not response.choices[0].message or not response.choices[0].message.content:
+            raise ValueError("Invalid response format - missing message content")
+            
+        return response.choices[0].message.content.strip()
+        
+    except Exception as e:
+        print(f"♣ LiteLLM API error: {str(e)}")
+        raise
+
+def get_ai_response(prompt: str, config: Dict, system_role: str = "code_fixer") -> str:
+    """
+    Get response from configured AI provider.
+    
+    Args:
+        prompt (str): The prompt to send to the AI
+        config (Dict): Configuration dictionary
+        system_role (str): Role for system prompt - "code_fixer", "analyzer", or "report"
+    
+    Returns:
+        str: The AI generated response
+    """
+    system_prompts = {
+        "code_fixer": "You are a Python code fixing assistant. Provide only the corrected code without explanations.",
+        "analyzer": "You are a Python error analysis assistant. Provide clear and concise explanation of the error and suggestions to fix it.",
+        "report": "You are a Python error reporting assistant. Provide a detailed report of the error, its cause, and the applied fix."
+    }
+    
+    system_prompt = system_prompts.get(system_role, system_prompts["code_fixer"])
+    
+    try:
+        provider = config.get('AI_PROVIDER', 'azure').lower()
+        
+        if provider == 'azure':
+            return _get_azure_response(prompt, config['AZURE'], system_prompt)
+        elif provider == 'openai':
+            return _get_openai_response(prompt, config['OPENAI'], system_prompt)
+        elif provider == 'anthropic':
+            return _get_anthropic_response(prompt, config['ANTHROPIC'])
+        elif provider == 'ollama':
+            return _get_ollama_response(prompt, config['OLLAMA'])
+        elif provider == 'litellm':
+            return _get_litellm_response(prompt, config['LITELLM'], system_prompt)
+        else:
+            raise ValueError(f"Unsupported AI provider: {provider}")
+            
+    except Exception as e:
+        print(f"♣ Error getting AI response: {str(e)}")
+        raise

healing_agent/ai_code_fixer.py

@@ -0,0 +1,174 @@
+import re
+from typing import Dict, Any
+from .ai_broker import get_ai_response
+
+def ensure_healing_agent_decorator(code: str) -> str:
+    """
+    Ensures the code has the @healing_agent decorator, adds it if missing.
+    
+    Args:
+        code (str): The code to check/modify
+        
+    Returns:
+        str: Code with @healing_agent decorator
+    """
+    # Check the first 5 lines for the @healing_agent decorator
+    lines = code.split('\n')[:5]
+    for line in lines:
+        if line.strip() == '@healing_agent':
+            return code  # Decorator already present
+
+    # If not found, add the decorator at the top
+    first_line = code.split('\n')[0]
+    indent = len(first_line) - len(first_line.lstrip())
+    decorator = ' ' * indent + '@healing_agent\n'
+    return decorator + code
+
+
+def prepare_fix_prompt(context: Dict[str, Any]) -> str:
+    """
+    Prepare the prompt for AI based on the context.
+    
+    Args:
+        context (Dict[str, Any]): The error context
+        
+    Returns:
+        str: Formatted prompt for the AI
+    """
+    # Extract function info if available
+    function_info = context.get('function_info', {})
+    function_args = context.get('function_arguments', {})
+    error_info = context.get('error', {})
+    
+    # Build argument info string
+    arg_info = ""
+    if function_args:
+        arg_info = "\nFunction was called with arguments:\n"
+        for arg_name, arg_data in function_args.items():
+            arg_info += f"{arg_name}: {arg_data.get('value')} (type: {arg_data.get('type')})\n"
+    
+    # Build function info string
+    func_info = ""
+    if function_info:
+        func_info = f"""
+Function Name: {function_info.get('name')}
+Function Signature: {function_info.get('signature')}
+Module: {function_info.get('module')}
+"""
+
+    # Build error details string
+    error_details = ""
+    if error_info.get('exception_attrs'):
+        error_details = "\nDetailed Error Information:\n"
+        for attr, value in error_info['exception_attrs'].items():
+            error_details += f"{attr}: {value}\n"
+
+    # Add traceback frames for context
+    traceback_info = ""
+    if error_info.get('traceback_frames'):
+        traceback_info = "\nTraceback Frames:\n"
+        for frame in error_info['traceback_frames']:
+            traceback_info += f"File: {frame['filename']}, Line {frame['line_number']}, in {frame['function']}\n"
+            traceback_info += f"Code: {frame['code']}\n"
+
+    # Include AI hint if available
+    ai_hint = ""
+    if context.get('ai_hint'):
+        ai_hint = f"\nAI Analysis:\n{context['ai_hint']}"
+
+    return f"""
+Fix the following Python code that produced an error, or at least handle the exceptions, add more info that could help debugging next time:
+
+Original Code:
+{context['function_info']['source_code']}
+
+Error Type: {context['error']['type']}
+Error Message: {context['error']['message']}
+Error Line Number: {context['error'].get('line_number')}
+Error Line: {context['error'].get('error_line')}
+
+{error_details}
+{traceback_info}
+{func_info}{arg_info}{ai_hint}
+
+Return only the fixed code without any explanations or markdown formatting.
+Ensure the fixed code maintains the same function name and signature.
+Add appropriate error handling where necessary.
+"""
+
+def validate_fixed_code(fixed_code: str) -> bool:
+    """
+    Validate the fixed code is syntactically correct.
+    
+    Args:
+        fixed_code (str): The code to validate
+        
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    try:
+        # Check if the code is syntactically valid Python
+        compile(fixed_code, '<string>', 'exec')
+        
+        # Basic checks for common issues
+        if not fixed_code.strip():
+            print("♣ Generated code is empty")
+            return False
+            
+        if "def " not in fixed_code:
+            print("♣ Generated code doesn't contain function definition")
+            return False
+            
+        return True
+        
+    except SyntaxError as e:
+        print(f"♣ Syntax error in generated code: {str(e)}")
+        return False
+    except Exception as e:
+        print(f"♣ Validation error: {str(e)}")
+        return False
+
+def fix(context: Dict[str, Any], config: Dict[str, Any]) -> str:
+    """
+    Fix buggy code using AI based on the provided context.
+    
+    Args:
+        context (Dict[str, Any]): Dictionary containing:
+            - original_code (str): The original buggy code
+            - error_info (Dict): Error details including type, message, traceback
+            - stack_trace (str): Full stack trace of the error
+            - function_name (str): Name of the function that caused the error
+            - additional_context (Dict): Any additional context that might help
+    
+    Returns:
+        str: The fixed version of the code
+    """
+    try:
+        # Prepare the prompt for AI
+        prompt = prepare_fix_prompt(context)
+        
+        # Get the fix from AI with code_fixer role
+        fixed_code = get_ai_response(prompt, config, "code_fixer")
+
+        # Remove markdown code block formatting if present
+        fixed_code = re.sub(r'^```python\n|^```\n|```$', '', fixed_code, flags=re.MULTILINE)
+        
+        # Ensure healing_agent decorator is present
+        fixed_code = ensure_healing_agent_decorator(fixed_code)
+        
+        # Validate the fixed code
+        if validate_fixed_code(fixed_code):
+
+            return fixed_code
+        else:
+            print("♣ Generated fix failed validation")
+            return
+
+    except Exception as e:
+        print(f"♣ Error during code fixing: {str(e)}")
+        print(f"♣ Error type: {type(e).__name__}")
+        print(f"♣ Error details: {repr(e)}")
+        print(f"♣ Error traceback:")
+        import traceback
+        traceback.print_exc()
+        return

healing_agent/ai_hint_generator.py

@@ -0,0 +1,89 @@
+from typing import Dict, Any
+from .ai_broker import get_ai_response
+
+def generate_hint(context: Dict[str, Any], config: Dict[str, Any]) -> str:
+    """
+    Generate an AI-powered hint based on the exception context.
+    
+    Args:
+        context (Dict[str, Any]): The exception context
+        config (Dict[str, Any]): The configuration dictionary
+        
+    Returns:
+        str: The generated AI hint
+    """
+    # Extract error information
+    error = context['error']
+    error_type = error['type']
+    error_message = error['message']
+    function_name = error['function_name']
+    traceback = error['traceback']
+    traceback_frames = error['traceback_frames']
+    exception_attrs = error['exception_attrs']
+    
+    # Extract any additional error details if present
+    error_details = ""
+    for detail_type in ['json_details', 'connection_details', 'timeout_details', 
+                       'http_details', 'value_details', 'key_details', 
+                       'type_details', 'file_details']:
+        if detail_type in error:
+            error_details += f"\n{detail_type}:\n{error[detail_type]}"
+    
+    # Get function info
+    function_info = context.get('function_info', {})
+    function_source = function_info.get('source_code', '')
+    function_module = function_info.get('module', '')
+    
+    # Get function arguments
+    function_arguments = context.get('function_arguments', {})
+    
+    # Get environment info
+    python_version = context.get('python_version', '')
+    platform = context.get('platform', '')
+    
+    # Prepare the prompt for AI
+    prompt = f"""
+An exception occurred in a Python program:
+
+ENVIRONMENT:
+Python Version: {python_version}
+Platform: {platform}
+
+ERROR DETAILS:
+Error Type: {error_type}
+Error Message: {error_message}
+Function Name: {function_name}
+Module: {function_module}
+
+Source Code:
+{function_source}
+
+Function Arguments:
+{function_arguments}
+
+Exception Attributes:
+{exception_attrs}
+
+Traceback:
+{traceback}
+
+Detailed Traceback Frames:
+{traceback_frames}
+
+Additional Error Details:
+{error_details}
+
+Based on all the provided context, generate a helpful hint or suggestion for resolving the issue. Consider:
+1. The exact error type and message
+2. The function's source code
+3. The values of arguments passed to the function
+4. Any additional error-specific details
+5. The full execution context from the traceback
+
+Provide the hint in a concise and clear manner, avoiding any code snippets or markdown formatting.
+"""
+    
+    # Get the AI-generated hint with analyzer role
+    hint = get_ai_response(prompt, config, system_role="analyzer")
+    
+    return hint