janito 3.4.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

janito/tools/__init__.py

@@ -1,6 +1,6 @@
-from janito.tools.adapters.local import (
-    local_tools_adapter as _internal_local_tools_adapter,
-    LocalToolsAdapter,
+from janito.tools.adapters.local import LocalToolsAdapter
+from janito.tools.adapters.local.adapter import (
+    LocalToolsAdapter as _internal_local_tools_adapter,
 )
 
 
@@ -11,8 +11,10 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
-    # Reuse the singleton adapter defined in janito.tools.adapters.local to maintain tool registrations
-    registry = _internal_local_tools_adapter
+    # Create and initialize adapter
+    from janito.tools.initialize import initialize_tools
+
+    registry = initialize_tools(LocalToolsAdapter(workdir=workdir))
     # Change workdir if requested
     if workdir is not None:
         try:
@@ -27,10 +29,32 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     return registry
 
 
-local_tools_adapter = _internal_local_tools_adapter
+# Initialize the global adapter - defer import to avoid circular dependencies
+local_tools_adapter = None
+
+
+def get_local_tools_adapter(workdir=None, allowed_permissions=None):
+    """Get the global tools adapter, initializing on first use."""
+    global local_tools_adapter
+    if local_tools_adapter is None:
+        from janito.tools.initialize import initialize_tools
+
+        adapter = LocalToolsAdapter(workdir=workdir)
+        local_tools_adapter = initialize_tools(adapter)
+
+    # Handle workdir if provided
+    if workdir is not None and local_tools_adapter is not None:
+        import os
+
+        if not os.path.exists(workdir):
+            os.makedirs(workdir, exist_ok=True)
+        os.chdir(workdir)
+        local_tools_adapter.workdir = workdir
+
+    return local_tools_adapter
+
 
 __all__ = [
     "LocalToolsAdapter",
     "get_local_tools_adapter",
-    "local_tools_adapter",
 ]

janito/tools/adapters/__init__.py

@@ -1 +1,6 @@
-# Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+"""
+Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+
+This package contains the core adapter infrastructure for managing tools,
+while the actual tool implementations have been moved to the plugins system.
+"""

janito/tools/adapters/local/__init__.py

@@ -1,73 +1,10 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .read_files import ReadFilesTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-from .read_chart import ReadChartTool
-from .show_image import ShowImageTool
-from .show_image_grid import ShowImageGridTool
-
-from janito.tools.tool_base import ToolPermissions
-import os
-from janito.tools.permissions import get_global_allowed_permissions
-
-# Singleton tools adapter with all standard tools registered
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+"""
+Local tools adapter for janito.
 
+This package provides the LocalToolsAdapter class which manages tool registration
+and execution for local, in-process tools.
+"""
 
-def get_local_tools_adapter(workdir=None):
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    ReadFilesTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-    ReadChartTool,
-    ShowImageTool,
-    ShowImageGridTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
+from .adapter import LocalToolsAdapter
 
-# DEBUG: Print registered tools at startup
+__all__ = ["LocalToolsAdapter"]

janito/tools/cli_initializer.py

@@ -0,0 +1,88 @@
+"""
+CLI-specific tool initialization for janito.
+
+This module provides functions to initialize tools specifically for CLI usage,
+handling circular imports and ensuring proper registration.
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+# Ensure current directory is in path
+sys.path.insert(0, str(Path.cwd()))
+
+
+def initialize_cli_tools():
+    """Initialize tools for CLI usage, avoiding circular imports."""
+    try:
+        from janito.tools.adapters.local.adapter import LocalToolsAdapter
+        from janito.plugin_system.core_loader_fixed import load_core_plugin
+        from janito.tools.permissions import set_global_allowed_permissions
+        from janito.tools.tool_base import ToolPermissions
+
+        # Create adapter
+        adapter = LocalToolsAdapter()
+
+        # Set permissions for CLI
+        set_global_allowed_permissions(
+            ToolPermissions(read=True, write=True, execute=True)
+        )
+
+        # Core plugins to load
+        core_plugins = [
+            "core.filemanager",
+            "core.codeanalyzer",
+            "core.system",
+            "core.imagedisplay",
+            "dev.pythondev",
+            "dev.visualization",
+        ]
+
+        loaded_count = 0
+        for plugin_name in core_plugins:
+            plugin = load_core_plugin(plugin_name)
+            if plugin:
+                tools = plugin.get_tools()
+                for tool_class in tools:
+                    try:
+                        adapter.register_tool(tool_class)
+                        loaded_count += 1
+                    except ValueError:
+                        # Tool already registered, skip
+                        pass
+
+        return adapter, loaded_count
+
+    except Exception as e:
+        print(f"Error initializing CLI tools: {e}", file=sys.stderr)
+        return None, 0
+
+
+def get_cli_tools_adapter():
+    """Get a CLI-initialized tools adapter."""
+    adapter, count = initialize_cli_tools()
+    if adapter and count > 0:
+        return adapter
+    return None
+
+
+def list_cli_tools():
+    """List all available CLI tools."""
+    adapter = get_cli_tools_adapter()
+    if not adapter:
+        return []
+
+    return adapter.list_tools()
+
+
+if __name__ == "__main__":
+    adapter, count = initialize_cli_tools()
+    if adapter:
+        tools = adapter.list_tools()
+        print(f"CLI initialized {count} tools")
+        print(f"Available tools: {len(tools)}")
+        for tool in sorted(tools):
+            print(f"  - {tool}")
+    else:
+        print("Failed to initialize CLI tools")

janito/tools/initialize.py

@@ -0,0 +1,70 @@
+"""
+Initialize janito tools for CLI and programmatic usage.
+
+This module provides functions to load core plugins and register their tools
+with the local tools adapter.
+"""
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from janito.plugin_system.core_loader_fixed import load_core_plugin
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+
+
+def initialize_tools(adapter: Optional[LocalToolsAdapter] = None) -> LocalToolsAdapter:
+    """
+    Initialize all janito tools by loading core plugins and registering tools.
+
+    Args:
+        adapter: LocalToolsAdapter instance to register tools with.
+                If None, creates a new instance.
+
+    Returns:
+        LocalToolsAdapter with all tools registered.
+    """
+    if adapter is None:
+        adapter = LocalToolsAdapter()
+
+    # Core plugins to load
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+    ]
+
+    loaded_count = 0
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                adapter.register_tool(tool_class)
+                loaded_count += 1
+
+    return adapter
+
+
+def get_initialized_adapter() -> LocalToolsAdapter:
+    """Get a pre-initialized LocalToolsAdapter with all tools registered."""
+    return initialize_tools()
+
+
+def list_available_tools() -> List[str]:
+    """Get a list of all available tool names."""
+    adapter = get_initialized_adapter()
+    return sorted(list(adapter._tools.keys()))
+
+
+if __name__ == "__main__":
+    adapter = initialize_tools()
+    tools = sorted(list(adapter._tools.keys()))
+
+    print(f"Initialized {len(tools)} tools")
+    print("Available tools:")
+    for tool_name in tools:
+        print(f"  - {tool_name}")

janito/tools/loop_protection_decorator.py

@@ -1,143 +1,140 @@
 import functools
 import time
 import threading
-from typing import Callable, Any
-from janito.tools.loop_protection import LoopProtection
-from janito.tools.tool_use_tracker import normalize_path
-
+from typing import Any, Tuple
 
 # 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.
 
-    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.
+    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).
     """
 
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            # Get the tool instance (self)
+            # Methods should always have self; if not, execute directly.
             if not args:
-                # This shouldn't happen in normal usage as methods need self
                 return func(*args, **kwargs)
 
-            # 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
+            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
             return func(*args, **kwargs)
 
         return wrapper