janito 3.2.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

janito/tools/function_adapter.py

@@ -0,0 +1,176 @@
+"""
+Function-to-Tool adapter for core plugins.
+
+This module provides a way to wrap function-based tools into proper ToolBase classes.
+"""
+
+import inspect
+from typing import Any, Dict, List, Optional, get_type_hints
+from janito.tools.tool_base import ToolBase, ToolPermissions
+
+
+class FunctionToolAdapter(ToolBase):
+    """
+    Adapter that wraps a function into a ToolBase class.
+    
+    This adapter provides a unified interface for function-based tools by wrapping
+    individual functions with the ToolBase protocol. It handles parameter mapping
+    and validation automatically.
+    
+    Parameters:
+        path (str): Target file path for file operations
+        content (str): File content to write or process
+        overwrite (bool): Whether to overwrite existing files (default: False)
+        sources (str): Source file(s) to copy from
+        target (str): Destination path for copy operations
+        recursive (bool): Whether to process directories recursively
+        from_line (int): Starting line number for file reading
+        to_line (int): Ending line number for file reading
+        search_text (str): Text to search for in files
+        replacement_text (str): Text to replace search matches with
+        use_regex (bool): Whether to treat search as regex pattern
+        case_sensitive (bool): Whether search should be case sensitive
+        max_depth (int): Maximum directory depth to search
+        include_gitignored (bool): Whether to include .gitignored files
+        timeout (int): Timeout in seconds for operations
+        require_confirmation (bool): Whether to require user confirmation
+        data (dict): Chart data for visualization tools
+        title (str): Chart title
+        width (int): Chart width in pixels
+        height (int): Chart height in pixels
+        query (str): Search query for text search
+        paths (str): Directory or file paths to search in
+        src_path (str): Source path for move operations
+        dest_path (str): Destination path for move operations
+        code (str): Python code to execute
+        pattern (str): File pattern to match (e.g., '*.py')
+    """
+
+    def __init__(self, func, tool_name: str = None, description: str = None):
+        super().__init__()
+        self._func = func
+        self.tool_name = tool_name or getattr(func, "tool_name", func.__name__)
+        self._description = description or func.__doc__ or f"Tool: {self.tool_name}"
+        self.permissions = ToolPermissions(read=True, write=True, execute=True)
+
+    def run(
+        self,
+        path: str = None,
+        content: str = None,
+        overwrite: bool = None,
+        sources: str = None,
+        target: str = None,
+        recursive: bool = None,
+        from_line: int = None,
+        to_line: int = None,
+        search_text: str = None,
+        replacement_text: str = None,
+        use_regex: bool = None,
+        case_sensitive: bool = None,
+        max_depth: int = None,
+        include_gitignored: bool = None,
+        timeout: int = None,
+        require_confirmation: bool = None,
+        data: dict = None,
+        title: str = None,
+        width: int = None,
+        height: int = None,
+        query: str = None,
+        paths: str = None,
+        src_path: str = None,
+        dest_path: str = None,
+        code: str = None,
+        pattern: str = None,
+    ) -> str:
+        """Execute the wrapped function."""
+        # Build kwargs from non-None parameters
+        import inspect
+
+        sig = inspect.signature(self._func)
+        filtered_kwargs = {}
+
+        # Map parameter names to their actual values
+        param_map = {
+            "path": path,
+            "content": content,
+            "overwrite": overwrite,
+            "sources": sources,
+            "target": target,
+            "recursive": recursive,
+            "from_line": from_line,
+            "to_line": to_line,
+            "search_text": search_text,
+            "replacement_text": replacement_text,
+            "use_regex": use_regex,
+            "case_sensitive": case_sensitive,
+            "max_depth": max_depth,
+            "include_gitignored": include_gitignored,
+            "timeout": timeout,
+            "require_confirmation": require_confirmation,
+            "data": data,
+            "title": title,
+            "width": width,
+            "height": height,
+            "query": query,
+            "paths": paths,
+            "src_path": src_path,
+            "dest_path": dest_path,
+            "code": code,
+            "pattern": pattern,
+        }
+
+        # Only include parameters that exist in the function signature
+        for name, param in sig.parameters.items():
+            if name in param_map and param_map[name] is not None:
+                filtered_kwargs[name] = param_map[name]
+
+        result = self._func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+
+    def get_signature(self) -> Dict[str, Any]:
+        """Get function signature for documentation."""
+        sig = inspect.signature(self._func)
+        type_hints = get_type_hints(self._func)
+
+        params = {}
+        for name, param in sig.parameters.items():
+            param_info = {
+                "type": str(type_hints.get(name, Any)),
+                "default": (
+                    param.default if param.default != inspect.Parameter.empty else None
+                ),
+                "required": param.default == inspect.Parameter.empty,
+            }
+            params[name] = param_info
+
+        return {
+            "name": self.tool_name,
+            "description": self._description,
+            "parameters": params,
+            "return_type": str(type_hints.get("return", Any)),
+        }
+
+
+def create_function_tool(func, tool_name: str = None, description: str = None) -> type:
+    """
+    Create a ToolBase class from a function.
+
+    Args:
+        func: The function to wrap
+        tool_name: Optional custom tool name
+        description: Optional custom description
+
+    Returns:
+        A ToolBase subclass that wraps the function
+    """
+    # Resolve tool_name in outer scope
+    resolved_tool_name = tool_name or getattr(func, "tool_name", func.__name__)
+
+    class DynamicFunctionTool(FunctionToolAdapter):
+        permissions = ToolPermissions(read=True, write=True, execute=True)
+        tool_name = resolved_tool_name
+
+        def __init__(self):
+            super().__init__(func, DynamicFunctionTool.tool_name, description)
+
+    return DynamicFunctionTool

janito/tools/initialize.py

@@ -9,7 +9,7 @@ import sys
 from pathlib import Path
 from typing import List, Optional
 
-from janito.plugin_system.core_loader_fixed import load_core_plugin
+from janito.plugins.core_loader import load_core_plugin
 from janito.tools.adapters.local.adapter import LocalToolsAdapter
 
 

janito/tools/loop_protection_decorator.py

@@ -1,140 +1,143 @@
 import functools
 import time
 import threading
-from typing import Any, Tuple
+from typing import Callable, Any
+from janito.tools.loop_protection import LoopProtection
+from janito.tools.tool_use_tracker import normalize_path
+
 
 # Global tracking for decorator-based loop protection
 _decorator_call_tracker = {}
 _decorator_call_tracker_lock = threading.Lock()
 
 
-def _normalize_key_value(key_field: str, key_value: Any) -> Any:
-    """Normalize key values, especially paths, so different representations map to the same key."""
-    if key_value is None:
-        return None
-
-    try:
-        if isinstance(key_field, str) and "path" in key_field.lower():
-            from janito.tools.tool_use_tracker import (
-                normalize_path as _norm,  # reuse existing normalization
-            )
-
-            if isinstance(key_value, str):
-                return _norm(key_value)
-            if isinstance(key_value, (list, tuple)):
-                return tuple(_norm(v) if isinstance(v, str) else v for v in key_value)
-    except Exception:
-        # Best-effort normalization – fall back to original value
-        pass
-
-    return key_value
-
-
-def _get_param_value(func, args, kwargs, key_field: str):
-    """Extract the watched parameter value from args/kwargs using function signature."""
-    if key_field in kwargs:
-        return kwargs[key_field]
-
-    # Handle positional arguments by mapping to parameter names
-    if len(args) > 1:  # args[0] is self
-        import inspect
-
-        try:
-            sig = inspect.signature(func)
-            param_names = list(sig.parameters.keys())
-            if key_field in param_names:
-                idx = param_names.index(key_field)
-                if idx < len(args):
-                    return args[idx]
-        except Exception:
-            return None
-
-    return None
-
-
-def _determine_operation_name(func, args, kwargs, key_field: str) -> str:
-    """Build the operation name for rate limiting, optionally including a normalized key value."""
-    if key_field:
-        raw_value = _get_param_value(func, args, kwargs, key_field)
-        if raw_value is not None:
-            norm_value = _normalize_key_value(key_field, raw_value)
-            return f"{func.__name__}_{norm_value}"
-    return func.__name__
-
-
-def _check_and_record(
-    op_name: str,
-    current_time: float,
-    time_window: float,
-    max_calls: int,
-    tool_instance: Any,
-) -> Tuple[bool, str]:
-    """Check loop limits for op_name and record the call. Returns (exceeded, message)."""
-    with _decorator_call_tracker_lock:
-        # Clean old timestamps
-        if op_name in _decorator_call_tracker:
-            _decorator_call_tracker[op_name] = [
-                ts
-                for ts in _decorator_call_tracker[op_name]
-                if current_time - ts <= time_window
-            ]
-
-        # Check limit
-        if (
-            op_name in _decorator_call_tracker
-            and len(_decorator_call_tracker[op_name]) >= max_calls
-        ):
-            if all(
-                current_time - ts <= time_window
-                for ts in _decorator_call_tracker[op_name]
-            ):
-                msg = (
-                    f"Loop protection: Too many {op_name} operations in a short time period "
-                    f"({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
-                )
-                if hasattr(tool_instance, "report_error"):
-                    try:
-                        tool_instance.report_error(msg)
-                    except Exception:
-                        pass
-                return True, msg
-
-        # Record this call
-        if op_name not in _decorator_call_tracker:
-            _decorator_call_tracker[op_name] = []
-        _decorator_call_tracker[op_name].append(current_time)
-
-    return False, ""
-
-
 def protect_against_loops(
     max_calls: int = 5, time_window: float = 10.0, key_field: str = None
 ):
     """
     Decorator that adds loop protection to tool run methods.
 
-    Tracks calls within a sliding time window and prevents excessive repeated operations.
-    When key_field is provided, the limit is applied per unique normalized value of that parameter
-    (e.g., per-path protection for file tools).
+    This decorator monitors tool executions and prevents excessive calls within
+    a configurable time window. It helps prevent infinite loops or excessive
+    resource consumption when tools are called repeatedly.
+
+    When the configured limits are exceeded, the decorator raises a RuntimeError
+    with a descriptive message. This exception will propagate up the call stack
+    unless caught by a try/except block in the calling code.
+
+    The decorator works by:
+    1. Tracking the number of calls to the decorated function
+    2. Checking if the calls exceed the configured limits
+    3. Raising a RuntimeError if a potential loop is detected
+    4. Allowing the method to proceed normally if the operation is safe
+
+    Args:
+        max_calls (int): Maximum number of calls allowed within the time window.
+                        Defaults to 5 calls.
+        time_window (float): Time window in seconds for detecting excessive calls.
+                            Defaults to 10.0 seconds.
+        key_field (str, optional): The parameter name to use for key matching instead of function name.
+                                 If provided, the decorator will track calls based on the value of this
+                                 parameter rather than the function name. Useful for tools that operate
+                                 on specific files or resources.
+
+    Example:
+        >>> @protect_against_loops(max_calls=3, time_window=5.0)
+        >>> def run(self, path: str) -> str:
+        >>>     # Implementation here
+        >>>     pass
+
+        >>> @protect_against_loops(max_calls=10, time_window=30.0)
+        >>> def run(self, file_paths: list) -> str:
+        >>>     # Implementation here
+        >>>     pass
+
+        >>> @protect_against_loops(max_calls=5, time_window=10.0, key_field='path')
+        >>> def run(self, path: str) -> str:
+        >>>     # This will track calls per unique path value
+        >>>     pass
+
+    Note:
+        When loop protection is triggered, a RuntimeError will be raised with a
+        descriptive message. This exception will propagate up the call stack
+        unless caught by a try/except block in the calling code.
     """
 
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            # Methods should always have self; if not, execute directly.
+            # Get the tool instance (self)
             if not args:
+                # This shouldn't happen in normal usage as methods need self
                 return func(*args, **kwargs)
 
-            op_name = _determine_operation_name(func, args, kwargs, key_field)
-            exceeded, msg = _check_and_record(
-                op_name=op_name,
-                current_time=time.time(),
-                time_window=time_window,
-                max_calls=max_calls,
-                tool_instance=args[0],
-            )
-            if exceeded:
-                return msg
+            # Determine the operation key
+            if key_field:
+                # Use the key_field parameter value as the operation key
+                key_value = None
+                if key_field in kwargs:
+                    key_value = kwargs[key_field]
+                elif len(args) > 1:
+                    # Handle positional arguments - need to map parameter names
+                    import inspect
+
+                    try:
+                        sig = inspect.signature(func)
+                        param_names = list(sig.parameters.keys())
+                        if key_field in param_names:
+                            field_index = param_names.index(key_field)
+                            if field_index < len(args):
+                                key_value = args[field_index]
+                    except (ValueError, TypeError):
+                        pass
+
+                if key_value is not None:
+                    op_name = f"{func.__name__}_{key_value}"
+                else:
+                    op_name = func.__name__
+            else:
+                # Use the function name as the operation name
+                op_name = func.__name__
+
+            # Check call limits
+            current_time = time.time()
+
+            with _decorator_call_tracker_lock:
+                # Clean up old entries outside the time window
+                if op_name in _decorator_call_tracker:
+                    _decorator_call_tracker[op_name] = [
+                        timestamp
+                        for timestamp in _decorator_call_tracker[op_name]
+                        if current_time - timestamp <= time_window
+                    ]
+
+                # Check if we're exceeding the limit
+                if op_name in _decorator_call_tracker:
+                    if len(_decorator_call_tracker[op_name]) >= max_calls:
+                        # Check if all recent calls are within the time window
+                        if all(
+                            current_time - timestamp <= time_window
+                            for timestamp in _decorator_call_tracker[op_name]
+                        ):
+                            # Return loop protection message as string instead of raising exception
+                            error_msg = f"Loop protection: Too many {op_name} operations in a short time period ({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
+
+                            # Try to report the error through the tool's reporting mechanism
+                            tool_instance = args[0] if args else None
+                            if hasattr(tool_instance, "report_error"):
+                                try:
+                                    tool_instance.report_error(error_msg)
+                                except Exception:
+                                    pass  # If reporting fails, we still return the message
+
+                            return error_msg
+
+                # Record this call
+                if op_name not in _decorator_call_tracker:
+                    _decorator_call_tracker[op_name] = []
+                _decorator_call_tracker[op_name].append(current_time)
+
+            # Proceed with the original function
             return func(*args, **kwargs)
 
         return wrapper