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

janito/llm/enter_cancellation.py

@@ -0,0 +1,107 @@
+"""
+Enter key cancellation for LLM requests.
+Allows pressing Enter to cancel ongoing requests.
+"""
+
+import threading
+import sys
+import time
+from typing import Optional
+
+
+class EnterCancellation:
+    """Handles Enter key cancellation of LLM requests."""
+
+    def __init__(self):
+        self._cancel_event: Optional[threading.Event] = None
+        self._listener_thread: Optional[threading.Thread] = None
+        self._listening = False
+
+    def start_monitoring(self, cancel_event: threading.Event):
+        """Start monitoring for Enter key to cancel the request."""
+        if self._listening:
+            return
+
+        self._cancel_event = cancel_event
+        self._listening = True
+
+        self._listener_thread = threading.Thread(
+            target=self._monitor_enter_key, daemon=True
+        )
+        self._listener_thread.start()
+
+    def stop_monitoring(self):
+        """Stop monitoring for keyboard input."""
+        self._listening = False
+        if self._listener_thread and self._listener_thread.is_alive():
+            self._listener_thread.join(timeout=0.1)
+
+    def _monitor_enter_key(self):
+        """Monitor for Enter key press."""
+        try:
+            self._handle_key_monitoring()
+        except Exception:
+            # Silently handle any errors
+            pass
+
+    def _handle_key_monitoring(self):
+        """Handle the actual key monitoring logic."""
+        import sys
+        import select
+
+        try:
+            import msvcrt  # Windows-specific keyboard input
+
+            self._monitor_windows_keys()
+        except ImportError:
+            self._monitor_unix_keys()
+
+    def _monitor_windows_keys(self):
+        """Monitor keys on Windows systems."""
+        import msvcrt
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if msvcrt.kbhit():
+                    char = msvcrt.getch()
+                    if char in [b"\r", b"\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                else:
+                    time.sleep(0.05)
+            except (IOError, OSError):
+                break
+
+    def _monitor_unix_keys(self):
+        """Monitor keys on Unix-like systems."""
+        import sys
+        import select
+
+        while (
+            self._listening and self._cancel_event and not self._cancel_event.is_set()
+        ):
+            try:
+                if sys.stdin in select.select([sys.stdin], [], [], 0.05)[0]:
+                    char = sys.stdin.read(1)
+                    if char in ["\r", "\n"]:
+                        if self._cancel_event:
+                            self._cancel_event.set()
+                        break
+                time.sleep(0.05)
+            except:
+                time.sleep(0.05)
+
+
+# Global instance
+_global_enter_cancellation = None
+
+
+def get_enter_cancellation() -> EnterCancellation:
+    """Get the global Enter cancellation instance."""
+    global _global_enter_cancellation
+    if _global_enter_cancellation is None:
+        _global_enter_cancellation = EnterCancellation()
+    return _global_enter_cancellation

janito/{plugin_system_backup_20250825_070018 → plugin_system}/core_loader.py

@@ -12,8 +12,7 @@ from pathlib import Path
 from typing import Optional, List, Type
 
 from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePlugin(Plugin):
@@ -38,12 +37,86 @@ class CorePlugin(Plugin):
     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,
+        }
+        
+        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 by creating tool classes."""
         self._tool_classes = []
         for tool_func in self._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)
 
 

janito/{plugin_system_backup_20250825_070018 → plugin_system}/core_loader_fixed.py

@@ -11,8 +11,7 @@ from pathlib import Path
 from typing import Optional, List, Type
 
 from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.function_adapter import create_function_tool
-from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class CorePlugin(Plugin):
@@ -37,12 +36,89 @@ class CorePlugin(Plugin):
     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 by creating tool classes."""
         self._tool_classes = []
         for tool_func in self._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)
 
 

janito/plugins/__init__.py

@@ -1,28 +1,36 @@
 """
-Unified Plugin System for Janito
+Plugin System for Development Tools
 
-This package provides a clean, unified plugin architecture for janito.
+This package organizes all available tools into logical plugin groups
+for easier discovery and usage.
 """
 
 __version__ = "1.0.0"
 __author__ = "Development Assistant"
 
-# Import core components
-from .base import Plugin, PluginMetadata, PluginResource
-from .manager import PluginManager
-from .discovery import discover_plugins, list_available_plugins
-from .config import load_plugins_config, save_plugins_config
-from .builtin import BuiltinPluginRegistry, load_builtin_plugin
-
-__all__ = [
-    "Plugin",
-    "PluginMetadata", 
-    "PluginResource",
-    "PluginManager",
-    "discover_plugins",
-    "list_available_plugins",
-    "load_plugins_config",
-    "save_plugins_config",
-    "BuiltinPluginRegistry",
-    "load_builtin_plugin",
-]
+from .core import filemanager, codeanalyzer, system, imagedisplay
+from .web import webtools
+from .dev import pythondev, visualization
+from .ui import userinterface
+
+# Plugin registry
+PLUGINS = {
+    "core.filemanager": filemanager,
+    "core.codeanalyzer": codeanalyzer,
+    "core.system": system,
+    "core.imagedisplay": imagedisplay,
+    "web.webtools": webtools,
+    "dev.pythondev": pythondev,
+    "dev.visualization": visualization,
+    "ui.userinterface": userinterface,
+}
+
+
+def list_plugins():
+    """Return all available plugins"""
+    return list(PLUGINS.keys())
+
+
+def get_plugin(name):
+    """Get a specific plugin by name"""
+    return PLUGINS.get(name)

janito/{plugins_backup_20250825_070018 → plugins}/auto_loader.py

@@ -13,7 +13,7 @@ from janito.plugins.discovery import list_available_plugins
 # List of core plugins that should be enabled by default
 CORE_PLUGINS = [
     "core.filemanager",
-    "core.codeanalyzer", 
+    "core.codeanalyzer",
     "core.system",
     "core.imagedisplay",
     "dev.pythondev",
@@ -26,23 +26,23 @@ CORE_PLUGINS = [
 def load_core_plugins(pm: PluginManager = None) -> List[str]:
     """
     Load all core plugins.
-    
+
     Args:
         pm: PluginManager instance. If None, creates a new one.
-        
+
     Returns:
         List of successfully loaded plugin names
     """
     if pm is None:
         pm = PluginManager()
-    
+
     # Ensure plugins directory is in search path
     plugins_dir = Path.cwd() / "plugins"
     if plugins_dir.exists():
         pm.add_plugin_path(str(plugins_dir))
-    
+
     loaded = []
-    
+
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -50,14 +50,14 @@ def load_core_plugins(pm: PluginManager = None) -> List[str]:
                 loaded.append(plugin_name)
         except Exception as e:
             print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
-    
+
     return loaded
 
 
 def get_loaded_core_plugins() -> List[str]:
     """
     Get list of currently loaded core plugins.
-    
+
     Returns:
         List of loaded core plugin names
     """
@@ -69,10 +69,10 @@ def get_loaded_core_plugins() -> List[str]:
 def is_core_plugin(plugin_name: str) -> bool:
     """
     Check if a plugin is a core plugin.
-    
+
     Args:
         plugin_name: Name of the plugin to check
-        
+
     Returns:
         True if it's a core plugin
     """
@@ -82,10 +82,11 @@ def is_core_plugin(plugin_name: str) -> bool:
 # Auto-load core plugins when module is imported
 _plugin_manager = None
 
+
 def get_plugin_manager() -> PluginManager:
     """Get the global plugin manager with core plugins loaded."""
     global _plugin_manager
     if _plugin_manager is None:
         _plugin_manager = PluginManager()
         load_core_plugins(_plugin_manager)
-    return _plugin_manager
+    return _plugin_manager

janito/plugins/builtin.py

@@ -7,7 +7,7 @@ with janito and available by default without requiring external installation.
 
 import importlib
 from typing import Dict, List, Optional, Type
-from .base import Plugin
+from janito.plugin_system.base import Plugin
 
 
 class BuiltinPluginRegistry:

janito/plugins/core/filemanager/tools/copy_file.py

@@ -13,36 +13,12 @@ from janito.i18n import tr
 class CopyFileTool(ToolBase):
     """
     Copy one or more files to a target directory, or copy a single file to a new file.
-    
-    Parameters:
+    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.
-        content (str): File content to write or process
-        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')
-    
     Returns:
         str: Status string for each copy operation.
     """

janito/plugins/core/filemanager/tools/create_directory.py

@@ -12,35 +12,8 @@ from janito.tools.path_utils import expand_path
 class CreateDirectoryTool(ToolBase):
     """
     Create a new directory at the specified path.
-    
-    Parameters:
+    Args:
         path (str): Path for the new directory.
-        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')
-    
     Returns:
         str: Status message indicating the result. Example:
             - "5c5 Successfully created the directory at ..."

janito/plugins/core/filemanager/tools/create_file.py

@@ -16,34 +16,10 @@ class CreateFileTool(ToolBase):
     """
     Create a new file with the given content.
 
-    Parameters:
+    Args:
         path (str): Path to the file to create.
         content (str): Content to write to the file.
         overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
-        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')
-
     Returns:
         str: Status message indicating the result. Example:
             - "✅ Successfully created the file at ..."
@@ -51,13 +27,13 @@ class CreateFileTool(ToolBase):
     Note: Syntax validation is automatically performed after this operation.
 
     Security: This tool includes loop protection to prevent excessive file creation operations.
-    Maximum 5 calls per 10 seconds for the same file path.
+    Protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds).
     """
 
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    @protect_against_loops(max_calls=1, time_window=10.0, key_field="path")
     def run(self, path: str, content: str, overwrite: bool = False) -> str:
         path = expand_path(path)
         disp_path = display_path(path)

janito/plugins/core/filemanager/tools/delete_text_in_file.py

@@ -15,7 +15,6 @@ class DeleteTextInFileTool(ToolBase):
         path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
-        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
 
     Returns:
         str: Status message indicating the result.

janito/plugins/core/imagedisplay/plugin.py

@@ -4,7 +4,7 @@ Image Display Plugin implementation.
 
 from typing import Dict, Any, List, Type
 
-from ...base import Plugin, PluginMetadata
+from janito.plugin_system.base import Plugin, PluginMetadata
 from janito.tools.tool_base import ToolBase
 from .tools.show_image import ShowImageTool
 from .tools.show_image_grid import ShowImageGridTool