naive-knowledge-base 0.1.0__py3-none-any.whl

agents/__init__.py

@@ -0,0 +1,7 @@
+"""Agents module for naive_knowledge_base."""
+
+from .dependency_graph import generate_dependency_graph
+
+__all__ = [
+    "generate_dependency_graph",
+]

agents/common/__init__.py

@@ -0,0 +1,28 @@
+from exceptions import (
+    CodeRefactorError,
+    ConfigurationError,
+    DependencyGraphError,
+    SonarQubeError,
+    RefactoringError,
+    FileOperationError,
+    MissingDependencyError,
+    wrap_exceptions
+)
+
+from .logging import configure_logging, get_logger
+
+__all__ = [
+    # Exceptions
+    "CodeRefactorError",
+    "ConfigurationError",
+    "DependencyGraphError",
+    "SonarQubeError",
+    "RefactoringError",
+    "FileOperationError",
+    "MissingDependencyError",
+    "wrap_exceptions",
+    
+    # Logging
+    "configure_logging",
+    "get_logger",
+]

agents/common/base.py

@@ -0,0 +1,187 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional, Union
+from smolagents import Tool, CodeAgent, ToolCallingAgent
+
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+class BaseAgent(ABC):
+    """
+    Abstract base class for all agents in the refactor system.
+    
+    This class defines the common interface that all agents must implement.
+    """
+    
+    @abstractmethod
+    def run(self, input_data: Any) -> Any:
+        """
+        Run the agent with the provided input data.
+        
+        Args:
+            input_data: Input data for the agent
+            
+        Returns:
+            Agent output
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the agent name."""
+        pass
+    
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """Get the agent description."""
+        pass
+
+class AnalysisAgent(BaseAgent):
+    """
+    Base class for agents that analyze code.
+    
+    These agents are responsible for analyzing code and providing information about it.
+    """
+    
+    @abstractmethod
+    def analyze(self, file_path: str, **kwargs) -> Dict[str, Any]:
+        """
+        Analyze the code in the given file.
+        
+        Args:
+            file_path: Path to the file to analyze
+            **kwargs: Additional arguments for the analysis
+            
+        Returns:
+            Analysis results
+        """
+        pass
+
+class RefactoringAgent(BaseAgent):
+    """
+    Base class for agents that refactor code.
+    
+    These agents are responsible for refactoring code based on analysis results.
+    """
+    
+    @abstractmethod
+    def generate_plan(self, file_path: str, analysis_results: Dict[str, Any]) -> str:
+        """
+        Generate a refactoring plan for the given file based on analysis results.
+        
+        Args:
+            file_path: Path to the file to refactor
+            analysis_results: Results from analysis agents
+            
+        Returns:
+            Refactoring plan
+        """
+        pass
+        
+    @abstractmethod
+    def execute_plan(self, file_path: str, plan: str) -> bool:
+        """
+        Execute a refactoring plan on the given file.
+        
+        Args:
+            file_path: Path to the file to refactor
+            plan: Refactoring plan
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        pass
+
+class SmolagentsAdapter(BaseAgent):
+    """
+    Adapter class for smolagents agents.
+    
+    This class adapts smolagents agents to our BaseAgent interface.
+    """
+    
+    def __init__(self, agent: Union[CodeAgent, ToolCallingAgent]):
+        """
+        Initialize the adapter.
+        
+        Args:
+            agent: The smolagents agent to adapt
+        """
+        self._agent = agent
+    
+    def run(self, input_data: Any) -> Any:
+        """
+        Run the smolagents agent.
+        
+        Args:
+            input_data: Input data for the agent
+            
+        Returns:
+            Agent output
+        """
+        return self._agent.run(input_data)
+    
+    @property
+    def name(self) -> str:
+        """Get the agent name."""
+        return self._agent.name
+    
+    @property
+    def description(self) -> str:
+        """Get the agent description."""
+        return self._agent.description
+    
+    @property
+    def agent(self) -> Union[CodeAgent, ToolCallingAgent]:
+        """Get the underlying smolagents agent."""
+        return self._agent
+
+class AgentFactory:
+    """
+    Factory class for creating agents.
+    
+    This class provides methods for creating different types of agents.
+    """
+    
+    @staticmethod
+    def create_analysis_agent(agent_type: str, **kwargs) -> AnalysisAgent:
+        """
+        Create an analysis agent of the specified type.
+        
+        Args:
+            agent_type: Type of analysis agent to create
+            **kwargs: Additional arguments for the agent
+            
+        Returns:
+            An instance of the requested analysis agent
+            
+        Raises:
+            ValueError: If the agent type is not supported
+        """
+        # Import here to avoid circular imports
+        from agents.sonar import create_sonar_agent
+        from agents.dependency_graph import create_dependency_graph_agent
+        
+        if agent_type == "sonar":
+            return create_sonar_agent(**kwargs)
+        elif agent_type == "dependency_graph":
+            return create_dependency_graph_agent(**kwargs)
+        else:
+            raise ValueError(f"Unsupported analysis agent type: {agent_type}")
+    
+    @staticmethod
+    def create_refactoring_agent(**kwargs) -> RefactoringAgent:
+        """
+        Create a refactoring agent.
+        
+        Args:
+            **kwargs: Additional arguments for the agent
+            
+        Returns:
+            An instance of the refactoring agent
+        """
+        # Import here to avoid circular imports
+        from agents.coder import create_coder_agent
+        
+        return create_coder_agent(**kwargs)

agents/common/exceptions.py

@@ -0,0 +1,62 @@
+from typing import Dict, Any, Optional
+
+class CodeRefactorError(Exception):
+    """Base exception for all code refactor errors."""
+    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
+        self.message = message
+        self.details = details or {}
+        super().__init__(self.message)
+
+class ConfigurationError(CodeRefactorError):
+    """Raised when there's an issue with configuration."""
+    pass
+
+class DependencyGraphError(CodeRefactorError):
+    """Raised when there's an issue with dependency graph generation or processing."""
+    pass
+
+class SonarQubeError(CodeRefactorError):
+    """Raised when there's an issue with SonarQube integration."""
+    pass
+
+class RefactoringError(CodeRefactorError):
+    """Raised when there's an issue with the refactoring process."""
+    pass
+
+class FileOperationError(CodeRefactorError):
+    """Raised when there's an issue with file operations."""
+    pass
+
+class MissingDependencyError(CodeRefactorError):
+    """Raised when a required dependency is missing."""
+    pass
+
+class TestingError(CodeRefactorError):
+    """Raised when there's an issue with the testing process."""
+    pass
+
+def wrap_exceptions(func):
+    """
+    Decorator to wrap exceptions with our custom exception types.
+    Example usage:
+    
+    @wrap_exceptions
+    def function_that_might_fail():
+        # function body
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except FileNotFoundError as e:
+            raise FileOperationError(f"File not found: {str(e)}", {"path": str(e)})
+        except PermissionError as e:
+            raise FileOperationError(f"Permission denied: {str(e)}", {"path": str(e)})
+        except ImportError as e:
+            raise MissingDependencyError(f"Missing dependency: {str(e)}")
+        except Exception as e:
+            # If it's already one of our exceptions, re-raise it
+            if isinstance(e, CodeRefactorError):
+                raise
+            # Otherwise wrap it
+            raise CodeRefactorError(f"Unexpected error: {str(e)}", {"original_error": str(e)})
+    return wrapper

agents/common/logging.py

@@ -0,0 +1,60 @@
+import logging
+import os
+import sys
+from typing import Optional
+
+# Configure the root logger
+def configure_logging(
+    log_level: str = "INFO",
+    log_file: Optional[str] = None,
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+):
+    """
+    Configure the logging system.
+    
+    Args:
+        log_level: The log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Path to the log file, if None, logs to console only
+        log_format: The format of the log messages
+    """
+    # Convert string log level to logging constant
+    numeric_level = getattr(logging, log_level.upper(), None)
+    if not isinstance(numeric_level, int):
+        raise ValueError(f"Invalid log level: {log_level}")
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    
+    # Clear existing handlers to avoid duplicates
+    root_logger.handlers = []
+    
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(logging.Formatter(log_format))
+    root_logger.addHandler(console_handler)
+    
+    # Create file handler if log_file is specified
+    if log_file:
+        # Ensure directory exists
+        log_dir = os.path.dirname(log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir)
+            
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(numeric_level)
+        file_handler.setFormatter(logging.Formatter(log_format))
+        root_logger.addHandler(file_handler)
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger with the specified name.
+    
+    Args:
+        name: The name of the logger
+        
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(name)

agents/common/schema_converter.py

@@ -0,0 +1,112 @@
+from typing import Dict, Any, List, Optional, Union, Callable
+import json
+from pydantic import BaseModel
+
+class SchemaConverter:
+    """
+    Converts between different schema formats for tool functions.
+    
+    This class handles conversion of parameters and return types between
+    different schema formats used by different libraries.
+    """
+    
+    @staticmethod
+    def convert_pydantic_to_dict(model_instance: BaseModel) -> Dict[str, Any]:
+        """
+        Convert a Pydantic model instance to a dictionary.
+        
+        Args:
+            model_instance: The Pydantic model instance to convert
+            
+        Returns:
+            The model as a dictionary
+        """
+        return model_instance.dict()
+    
+    @staticmethod
+    def convert_dict_to_pydantic(data: Dict[str, Any], model_class: type) -> BaseModel:
+        """
+        Convert a dictionary to a Pydantic model instance.
+        
+        Args:
+            data: The dictionary data to convert
+            model_class: The Pydantic model class to convert to
+            
+        Returns:
+            An instance of the specified Pydantic model
+        """
+        return model_class(**data)
+    
+    @staticmethod
+    def convert_json_to_pydantic(json_str: str, model_class: type) -> BaseModel:
+        """
+        Convert a JSON string to a Pydantic model instance.
+        
+        Args:
+            json_str: The JSON string to convert
+            model_class: The Pydantic model class to convert to
+            
+        Returns:
+            An instance of the specified Pydantic model
+        """
+        data = json.loads(json_str)
+        return SchemaConverter.convert_dict_to_pydantic(data, model_class)
+    
+    @staticmethod
+    def wrap_function_for_schema_conversion(
+        func: Callable,
+        input_conversions: Dict[str, type] = None,
+        output_conversion: Optional[type] = None
+    ) -> Callable:
+        """
+        Wraps a function to handle schema conversions automatically.
+        
+        Args:
+            func: The function to wrap
+            input_conversions: Mapping of parameter names to Pydantic model classes for conversion
+            output_conversion: Pydantic model class for converting the function output
+            
+        Returns:
+            A wrapped function that handles schema conversions
+        """
+        input_conversions = input_conversions or {}
+        
+        def wrapper(*args, **kwargs):
+            # Convert input parameters based on specified conversions
+            converted_kwargs = kwargs.copy()
+            
+            for param_name, model_class in input_conversions.items():
+                if param_name in kwargs:
+                    # Special case for JSON strings
+                    if isinstance(kwargs[param_name], str) and kwargs[param_name].startswith('{'):
+                        try:
+                            converted_kwargs[param_name] = SchemaConverter.convert_json_to_pydantic(
+                                kwargs[param_name], model_class
+                            )
+                        except (json.JSONDecodeError, ValueError):
+                            # Not a valid JSON string, keep original
+                            pass
+                    # Dict to model conversion
+                    elif isinstance(kwargs[param_name], dict):
+                        converted_kwargs[param_name] = SchemaConverter.convert_dict_to_pydantic(
+                            kwargs[param_name], model_class
+                        )
+            
+            # Call the original function with converted parameters
+            result = func(*args, **converted_kwargs)
+            
+            # Convert output if needed
+            if output_conversion and isinstance(result, BaseModel):
+                return SchemaConverter.convert_pydantic_to_dict(result)
+            elif output_conversion and isinstance(result, dict):
+                # Create a model instance and then convert back to dict to ensure schema compliance
+                model_instance = SchemaConverter.convert_dict_to_pydantic(result, output_conversion)
+                return SchemaConverter.convert_pydantic_to_dict(model_instance)
+            
+            return result
+        
+        # Preserve the original function's metadata
+        wrapper.__name__ = func.__name__
+        wrapper.__doc__ = func.__doc__
+        
+        return wrapper

agents/common/tools.py

@@ -0,0 +1,195 @@
+from typing import Callable, Dict, Any, TypeVar, Protocol, Optional, List, Union
+from functools import wraps
+import inspect
+from smolagents import tool as smolagents_tool
+from pydantic import create_model, BaseModel, Field
+
+from logging import get_logger
+from exceptions import CodeRefactorError
+
+logger = get_logger(__name__)
+
+T = TypeVar('T')
+
+class Tool(Protocol):
+    """Protocol for tool functions."""
+    
+    @property
+    def name(self) -> str:
+        """Get the tool name."""
+        ...
+    
+    @property
+    def description(self) -> str:
+        """Get the tool description."""
+        ...
+    
+    def __call__(self, *args, **kwargs) -> Any:
+        """Call the tool."""
+        ...
+
+def tool(func: Callable) -> Tool:
+    """
+    Decorator for tool functions.
+    
+    This decorator wraps a function to provide standardized error handling and logging.
+    It also validates that the function has proper type hints and docstrings.
+    
+    Args:
+        func: The function to wrap
+        
+    Returns:
+        The wrapped function
+    """
+    # Get function signature
+    sig = inspect.signature(func)
+    
+    # Extract parameter types from type hints
+    param_types = {}
+    for name, param in sig.parameters.items():
+        if param.annotation is inspect.Parameter.empty:
+            logger.warning(f"Parameter {name} in {func.__name__} missing type hint")
+            continue
+        param_types[name] = param.annotation
+    
+    # Create pydantic model for parameters
+    fields = {}
+    for name, type_ in param_types.items():
+        # Extract description from docstring if available
+        param_desc = ""
+        if func.__doc__:
+            for line in func.__doc__.split('\n'):
+                if f"{name}:" in line or f"{name} (" in line:
+                    parts = line.split(':', 1)
+                    if len(parts) > 1:
+                        param_desc = parts[1].strip()
+                        break
+        
+        fields[name] = (type_, Field(..., description=param_desc))
+    
+    # Create model class
+    model_name = f"{func.__name__.title()}Model"
+    model = create_model(model_name, **fields)
+    
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            # Validate parameters
+            params = model(**kwargs)
+            
+            # Execute function
+            logger.debug(f"Executing tool {func.__name__}")
+            result = func(*args, **{k: v for k, v in params.dict().items() if k in kwargs})
+            
+            # Log success
+            logger.debug(f"Tool {func.__name__} executed successfully")
+            
+            return result
+        except Exception as e:
+            # Log error
+            logger.error(f"Error executing tool {func.__name__}: {str(e)}")
+            
+            # Wrap exception
+            if not isinstance(e, CodeRefactorError):
+                e = CodeRefactorError(f"Tool {func.__name__} failed: {str(e)}")
+            
+            raise e
+    
+    # Add tool name and description
+    wrapper.name = func.__name__
+    wrapper.description = func.__doc__ or ""
+    
+    # Decorate with smolagents tool decorator
+    decorated_func = smolagents_tool(func)
+    
+    # Copy attributes from smolagents_tool
+    for attr in dir(decorated_func):
+        if not attr.startswith('__'):
+            setattr(wrapper, attr, getattr(decorated_func, attr))
+    
+    return wrapper
+
+def create_tool_registry():
+    """
+    Create a registry for tools.
+    
+    Returns:
+        A dictionary for registering tools
+    """
+    return {'tools': {}}
+
+def register_tool(registry: Dict[str, Dict[str, Tool]], tool_func: Tool) -> Tool:
+    """
+    Register a tool function in the registry.
+    
+    Args:
+        registry: The tool registry
+        tool_func: The tool function to register
+        
+    Returns:
+        The registered tool function
+    """
+    registry['tools'][tool_func.name] = tool_func
+    return tool_func
+
+def get_tool(registry: Dict[str, Dict[str, Tool]], name: str) -> Optional[Tool]:
+    """
+    Get a tool from the registry by name.
+    
+    Args:
+        registry: The tool registry
+        name: The name of the tool
+        
+    Returns:
+        The tool function or None if not found
+    """
+    return registry['tools'].get(name)
+
+def get_all_tools(registry: Dict[str, Dict[str, Tool]]) -> List[Tool]:
+    """
+    Get all tools from the registry.
+    
+    Args:
+        registry: The tool registry
+        
+    Returns:
+        List of all tool functions
+    """
+    return list(registry['tools'].values())
+
+# Create global tool registry
+tool_registry = create_tool_registry()
+
+def register(func: Callable) -> Tool:
+    """
+    Register a tool function in the global registry.
+    
+    Args:
+        func: The function to register
+        
+    Returns:
+        The registered tool function
+    """
+    tool_func = tool(func)
+    return register_tool(tool_registry, tool_func)
+
+def get(name: str) -> Optional[Tool]:
+    """
+    Get a tool from the global registry by name.
+    
+    Args:
+        name: The name of the tool
+        
+    Returns:
+        The tool function or None if not found
+    """
+    return get_tool(tool_registry, name)
+
+def get_all() -> List[Tool]:
+    """
+    Get all tools from the global registry.
+    
+    Returns:
+        List of all tool functions
+    """
+    return get_all_tools(tool_registry)