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

janito/{tools/adapters/local → plugins/core/imagedisplay/tools}/show_image_grid.py

@@ -1,12 +1,10 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 from janito.tools.loop_protection_decorator import protect_against_loops
 from typing import Sequence
 
 
-@register_local_tool
 class ShowImageGridTool(ToolBase):
     """Display multiple images in a grid inline in the terminal using rich.
 
@@ -50,7 +48,9 @@ class ShowImageGridTool(ToolBase):
         if not paths:
             return tr("No images provided")
 
-        self.report_action(tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ)
+        self.report_action(
+            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
+        )
 
         console = Console()
         images = []
@@ -63,7 +63,9 @@ class ShowImageGridTool(ToolBase):
             try:
                 img = PILImage.open(fp)
                 title = f"{display_path(fp)} ({img.width}x{img.height})"
-                images.append(Panel.fit(title, title=display_path(fp), border_style="dim"))
+                images.append(
+                    Panel.fit(title, title=display_path(fp), border_style="dim")
+                )
                 shown += 1
             except Exception as e:
                 self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
@@ -71,6 +73,12 @@ class ShowImageGridTool(ToolBase):
         if not images:
             return tr("No images could be displayed")
 
+        # Render in columns (grid-like)
         console.print(Columns(images, equal=True, expand=True, columns=columns))
         self.report_success(tr("✅ Displayed {n} images", n=shown))
-        return tr("Displayed {shown}/{total} images in a {cols}x? grid", shown=shown, total=len(paths), cols=columns)
+        return tr(
+            "Displayed {shown}/{total} images in a {cols}x? grid",
+            shown=shown,
+            total=len(paths),
+            cols=columns,
+        )

janito/plugins/core/system/__init__.py

@@ -0,0 +1,23 @@
+"""
+System Tools Plugin
+
+System-level operations and shell access.
+"""
+
+from typing import Optional
+
+
+def run_powershell_command(
+    command: str, timeout: int = 60, require_confirmation: bool = False
+) -> str:
+    """Execute PowerShell commands"""
+    return f"run_powershell_command(command='{command[:50]}...', timeout={timeout})"
+
+
+run_powershell_command.tool_name = "run_powershell_command"
+
+
+# Plugin metadata
+__plugin_name__ = "core.system"
+__plugin_description__ = "System-level operations and shell access"
+__plugin_tools__ = [run_powershell_command]

janito/plugins/core_adapter.py

@@ -5,25 +5,24 @@ This module provides proper Plugin class implementations for core plugins
 that use the function-based approach instead of class-based.
 """
 
-from janito.plugins.base import Plugin, PluginMetadata
+from janito.plugin_system.base import Plugin, PluginMetadata
 from typing import List, Type
-from janito.tools.tool_base import ToolBase
-from janito.tools.function_adapter import create_function_tool
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePluginAdapter(Plugin):
     """Adapter for core plugins using function-based tools."""
-    
+
     def __init__(self, plugin_name: str, description: str, tools_module):
         super().__init__()
         self._plugin_name = plugin_name
         self._description = description
         self._tools_module = tools_module
         self._tool_classes = []
-        
+
         # Set the metadata attribute that Plugin expects
         self.metadata = self.get_metadata()
-        
+
     def get_metadata(self) -> PluginMetadata:
         return PluginMetadata(
             name=self._plugin_name,
@@ -32,22 +31,101 @@ class CorePluginAdapter(Plugin):
             author="Janito",
             license="MIT",
         )
-    
+
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
+
+    def _create_tool_class(self, func):
+        """Create a ToolBase class from a function."""
+        resolved_tool_name = getattr(func, "tool_name", func.__name__)
+        
+        # Create a proper tool class with explicit parameters and documentation
+        import inspect
+        from typing import get_type_hints
+        
+        func_sig = inspect.signature(func)
+        type_hints = get_type_hints(func)
+        
+        # Build parameter definitions for the run method
+        param_defs = []
+        param_docs = []
+        for name, param in func_sig.parameters.items():
+            type_hint = type_hints.get(name, str)
+            if param.default == inspect.Parameter.empty:
+                param_defs.append(f"{name}: {type_hint.__name__}")
+            else:
+                param_defs.append(f"{name}: {type_hint.__name__} = {repr(param.default)}")
+            
+            # Add parameter documentation
+            param_docs.append(f"    {name}: {type_hint.__name__} - Parameter {name}")
+        
+        # Get function docstring or create one
+        func_doc = func.__doc__ or f"Execute {resolved_tool_name} tool"
+        
+        # Create the tool class with proper signature and documentation
+        exec_globals = {
+            'ToolBase': ToolBase,
+            'ToolPermissions': ToolPermissions,
+            'func': func,
+            'inspect': inspect,
+            'str': str,
+            'List': list,
+            'Dict': dict,
+            'Optional': type(None),
+        }
+        
+        param_docs_str = '\n'.join(param_docs)
+        
+        class_def = f'''
+class DynamicTool(ToolBase):
+    """
+    {func_doc}
+    
+    Parameters:
+{param_docs_str}
+    
+    Returns:
+        str: Execution result
+    """
+    tool_name = "{resolved_tool_name}"
+    permissions = ToolPermissions(read=True, write=True, execute=True)
     
+    def __init__(self):
+        super().__init__()
+    
+    def run(self, {', '.join(param_defs)}) -> str:
+        kwargs = locals()
+        sig = inspect.signature(func)
+        
+        # Filter kwargs to only include parameters the function accepts
+        filtered_kwargs = {{}}
+        for name, param in sig.parameters.items():
+            if name in kwargs and kwargs[name] is not None:
+                filtered_kwargs[name] = kwargs[name]
+        
+        result = func(**filtered_kwargs)
+        return str(result) if result is not None else ""
+'''
+        
+        exec(class_def, exec_globals)
+        return exec_globals['DynamicTool']
+        
+        return DynamicTool
+
     def initialize(self):
         """Initialize the plugin by creating tool classes."""
         # Get tools from the module
         tools = getattr(self._tools_module, "__plugin_tools__", [])
-        
+
         self._tool_classes = []
         for tool_func in tools:
             if callable(tool_func):
-                tool_class = create_function_tool(tool_func)
+                tool_class = self._create_tool_class(tool_func)
                 self._tool_classes.append(tool_class)
 
 
-def create_core_plugin(plugin_name: str, description: str, tools_module) -> CorePluginAdapter:
+def create_core_plugin(
+    plugin_name: str, description: str, tools_module
+) -> CorePluginAdapter:
     """Create a core plugin adapter."""
-    return CorePluginAdapter(plugin_name, description, tools_module)
+    return CorePluginAdapter(plugin_name, description, tools_module)

janito/plugins/dev/__init__.py

@@ -0,0 +1,7 @@
+"""
+Development Plugin Package
+
+Contains development-specific tools and utilities.
+"""
+
+__all__ = ["pythondev", "visualization"]

janito/plugins/dev/pythondev/__init__.py

@@ -0,0 +1,37 @@
+"""
+Python Development Plugin
+
+Python development and execution tools.
+"""
+
+from typing import Optional
+
+
+def python_code_run(code: str, timeout: int = 60) -> str:
+    """Execute Python code via stdin"""
+    return f"python_code_run(code='{len(code)} chars', timeout={timeout})"
+
+
+python_code_run.tool_name = "python_code_run"
+
+
+def python_command_run(code: str, timeout: int = 60) -> str:
+    """Execute Python with -c flag"""
+    return f"python_command_run(code='{len(code)} chars', timeout={timeout})"
+
+
+python_command_run.tool_name = "python_command_run"
+
+
+def python_file_run(path: str, timeout: int = 60) -> str:
+    """Run Python script files"""
+    return f"python_file_run(path='{path}', timeout={timeout})"
+
+
+python_file_run.tool_name = "python_file_run"
+
+
+# Plugin metadata
+__plugin_name__ = "dev.pythondev"
+__plugin_description__ = "Python development and execution"
+__plugin_tools__ = [python_code_run, python_command_run, python_file_run]

janito/plugins/dev/visualization/__init__.py

@@ -0,0 +1,23 @@
+"""
+Visualization Plugin
+
+Data visualization and charting tools.
+"""
+
+from typing import Dict, Any
+
+
+def read_chart(
+    data: Dict[str, Any], title: str = "Chart", width: int = 80, height: int = 20
+) -> str:
+    """Display charts in terminal (bar, line, pie, table)"""
+    return f"read_chart(type='{data.get('type')}', title='{title}')"
+
+
+read_chart.tool_name = "read_chart"
+
+
+# Plugin metadata
+__plugin_name__ = "dev.visualization"
+__plugin_description__ = "Data visualization and charts"
+__plugin_tools__ = [read_chart]

janito/plugins/discovery.py

@@ -31,9 +31,9 @@ from pathlib import Path
 from typing import Optional, List
 import logging
 
-from .base import Plugin
+from janito.plugin_system.base import Plugin
 from .builtin import load_builtin_plugin, BuiltinPluginRegistry
-from .core_loader import load_core_plugin
+from janito.plugin_system.core_loader import load_core_plugin
 
 logger = logging.getLogger(__name__)
 
@@ -75,13 +75,13 @@ def discover_plugins(
         parts = plugin_name.split(".")
         if len(parts) == 2:
             package_name, submodule_name = parts
-            
+
             # Handle core plugins with dedicated loader
             if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
                 plugin = load_core_plugin(plugin_name)
                 if plugin:
                     return plugin
-                    
+
             for base_path in all_paths:
                 package_path = base_path / package_name / submodule_name / "__init__.py"
                 if package_path.exists():
@@ -157,7 +157,7 @@ def _load_plugin_from_file(
 
         # Check for package-based plugin with __plugin_name__ metadata
         if hasattr(module, "__plugin_name__"):
-            from janito.plugins.base import PluginMetadata
+            from janito.plugin_system.base import PluginMetadata
 
             # Create a dynamic plugin class
             class PackagePlugin(Plugin):

janito/plugins/discovery_core.py

@@ -17,11 +17,11 @@ from .core_adapter import CorePluginAdapter
 def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin from a package directory.
-    
+
     Args:
         package_path: Path to the __init__.py file
         plugin_name: Full plugin name (e.g., core.filemanager)
-        
+
     Returns:
         Plugin instance if loaded successfully
     """
@@ -30,20 +30,25 @@ def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
         spec = importlib.util.spec_from_file_location(plugin_name, package_path)
         if spec is None or spec.loader is None:
             return None
-            
+
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
-        
+
         # Get plugin metadata
         plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
-        
+        description = getattr(
+            module, "__plugin_description__", f"Core plugin: {plugin_name}"
+        )
+
         # Create and return the core plugin adapter
         plugin = CorePluginAdapter(plugin_name_attr, description, module)
         plugin.initialize()  # Initialize to set up tools
         return plugin
-        
+
     except Exception as e:
         import logging
-        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
-        return None
+
+        logging.getLogger(__name__).error(
+            f"Failed to load core plugin {plugin_name}: {e}"
+        )
+        return None

janito/plugins/example_plugin.py

@@ -0,0 +1,108 @@
+"""
+Example plugin demonstrating the plugin system.
+"""
+
+from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from typing import Dict, Any
+
+
+class HelloWorldTool(ToolBase):
+    """A simple tool that says hello."""
+
+    tool_name = "hello_world"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, name: str = "World") -> str:
+        """
+        Say hello to someone.
+
+        Args:
+            name: Name of the person to greet
+
+        Returns:
+            Greeting message
+        """
+        self.report_action(f"Saying hello to {name}", "greet")
+        return f"Hello, {name}!"
+
+
+class CalculatorTool(ToolBase):
+    """A simple calculator tool."""
+
+    tool_name = "calculator"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, operation: str, a: float, b: float) -> str:
+        """
+        Perform basic calculations.
+
+        Args:
+            operation: Operation to perform (add, subtract, multiply, divide)
+            a: First number
+            b: Second number
+
+        Returns:
+            Result as string
+        """
+        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
+
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                return "Error: Division by zero"
+            result = a / b
+        else:
+            return f"Error: Unknown operation '{operation}'"
+
+        return str(result)
+
+
+class ExamplePlugin(Plugin):
+    """Example plugin providing basic tools."""
+
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name="example",
+            version="1.0.0",
+            description="Example plugin with basic tools",
+            author="Janito Team",
+            license="MIT",
+            homepage="https://github.com/janito/example-plugin",
+        )
+
+    def get_tools(self):
+        return [HelloWorldTool, CalculatorTool]
+
+    def initialize(self):
+        print("Example plugin initialized!")
+
+    def cleanup(self):
+        print("Example plugin cleaned up!")
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Return JSON schema for plugin configuration."""
+        return {
+            "type": "object",
+            "properties": {
+                "greeting_prefix": {
+                    "type": "string",
+                    "description": "Custom greeting prefix for hello_world tool",
+                    "default": "Hello",
+                },
+                "max_calculation": {
+                    "type": "number",
+                    "description": "Maximum allowed calculation result",
+                    "default": 1000000,
+                },
+            },
+        }
+
+
+# This makes the plugin discoverable
+PLUGIN_CLASS = ExamplePlugin

janito/plugins/manager.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Any
 import logging
 
-from .base import Plugin, PluginMetadata
+from janito.plugin_system.base import Plugin, PluginMetadata
 from .discovery import discover_plugins
 from .config import load_plugins_config, get_user_plugins_dir
 from .builtin import BuiltinPluginRegistry, load_builtin_plugin

janito/plugins/tools/__init__.py

@@ -0,0 +1,10 @@
+"""
+Core tools plugin for janito.
+
+This plugin provides the essential tools for file operations, code execution,
+and system interactions that are core to janito's functionality.
+"""
+
+from .core_tools_plugin import CoreToolsPlugin
+
+__all__ = ["CoreToolsPlugin"]

janito/{tools/adapters/local → plugins/tools}/ask_user.py

@@ -1,5 +1,5 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 from rich import print as rich_print
@@ -16,8 +16,8 @@ from prompt_toolkit.styles import Style
 toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
 
 
-@register_local_tool
-class AskUserTool(ToolBase):
+@register_core_tool
+class AskUser(ToolBase):
     """
     Prompts the user for clarification or input with a question.
 

janito/plugins/tools/copy_file.py

@@ -0,0 +1,87 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from typing import List, Union
+from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.tools.tool_utils import display_path
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_core_tool
+class CopyFile(ToolBase):
+    """
+    Copy one or more files to a target directory, or copy a single file to a new file.
+    Args:
+        sources (str): Space-separated path(s) to the file(s) to copy.
+            For multiple sources, provide a single string with paths separated by spaces.
+        target (str): Destination path. If copying multiple sources, this must be an existing directory.
+        overwrite (bool, optional): Overwrite existing files. Default: False.
+            Recommended only after reading the file to be overwritten.
+    Returns:
+        str: Status string for each copy operation.
+    """
+
+    permissions = ToolPermissions(read=True, write=True)
+    tool_name = "copy_file"
+
+    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
+        source_list = [expand_path(src) for src in sources.split() if src]
+        target = expand_path(target)
+        messages = []
+        if len(source_list) > 1:
+            if not os.path.isdir(target):
+                return tr(
+                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
+                    target=display_path(target),
+                )
+            for src in source_list:
+                if not os.path.isfile(src):
+                    messages.append(
+                        tr(
+                            "❗ Source file does not exist: '{src}'",
+                            src=display_path(src),
+                        )
+                    )
+                    continue
+                dst = os.path.join(target, os.path.basename(src))
+                messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        else:
+            src = source_list[0]
+            if os.path.isdir(target):
+                dst = os.path.join(target, os.path.basename(src))
+            else:
+                dst = target
+            messages.append(self._copy_one(src, dst, overwrite=overwrite))
+        return "\n".join(messages)
+
+    def _copy_one(self, src, dst, overwrite=False) -> str:
+        disp_src = display_path(src)
+        disp_dst = display_path(dst)
+        if not os.path.isfile(src):
+            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
+        if os.path.exists(dst) and not overwrite:
+            return tr(
+                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
+                dst=disp_dst,
+            )
+        try:
+            os.makedirs(os.path.dirname(dst), exist_ok=True)
+            shutil.copy2(src, dst)
+            note = (
+                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
+                if (os.path.exists(dst) and overwrite)
+                else ""
+            )
+            self.report_success(
+                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
+            )
+            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
+        except Exception as e:
+            return tr(
+                "❗ Copy failed from '{src}' to '{dst}': {err}",
+                src=disp_src,
+                dst=disp_dst,
+                err=str(e),
+            )