janito 2.32.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

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/function_adapter.py

@@ -11,55 +11,132 @@ from janito.tools.tool_base import ToolBase, ToolPermissions
 
 class FunctionToolAdapter(ToolBase):
     """Adapter that wraps a function into a ToolBase class."""
-    
+
     def __init__(self, func, tool_name: str = None, description: str = None):
         super().__init__()
         self._func = func
-        self.tool_name = tool_name or func.__name__
+        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, **kwargs) -> Any:
+
+    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."""
-        return self._func(**kwargs)
-    
+        # 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,
+                "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))
+            "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, tool_name, description)
-    
-    return DynamicFunctionTool
+            super().__init__(func, DynamicFunctionTool.tool_name, description)
+
+    return DynamicFunctionTool

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-2.32.0.dist-info → janito-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.32.0
+Version: 3.0.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -30,7 +30,6 @@ Requires-Dist: black; extra == "dev"
 Requires-Dist: questionary>=2.0.1; extra == "dev"
 Requires-Dist: setuptools_scm>=8.0; extra == "dev"
 Provides-Extra: coder
-Requires-Dist: janito-coder; extra == "coder"
 Dynamic: license-file
 
 # nctl