janito 2.33.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

janito/llm/cancellation_manager.py

@@ -0,0 +1,62 @@
+"""
+Global cancellation manager for LLM requests.
+Provides a centralized way to cancel ongoing requests.
+"""
+
+import threading
+from typing import Optional
+
+
+class CancellationManager:
+    """Manages cancellation of LLM requests across the application."""
+    
+    def __init__(self):
+        self._current_cancel_event: Optional[threading.Event] = None
+        self._lock = threading.Lock()
+        self._keyboard_cancellation = None
+        
+    def start_new_request(self) -> threading.Event:
+        """Start a new request and return its cancellation event."""
+        with self._lock:
+            # Create new cancellation event for this request
+            self._current_cancel_event = threading.Event()
+            
+            # Start keyboard monitoring
+            from janito.llm.enter_cancellation import get_enter_cancellation
+            self._keyboard_cancellation = get_enter_cancellation()
+            self._keyboard_cancellation.start_monitoring(self._current_cancel_event)
+            
+            return self._current_cancel_event
+    
+    def cancel_current_request(self) -> bool:
+        """Cancel the current request if one is active."""
+        with self._lock:
+            if self._current_cancel_event is not None:
+                self._current_cancel_event.set()
+                return True
+            return False
+    
+    def get_current_cancel_event(self) -> Optional[threading.Event]:
+        """Get the current cancellation event."""
+        with self._lock:
+            return self._current_cancel_event
+    
+    def clear_current_request(self):
+        """Clear the current request cancellation event."""
+        with self._lock:
+            if self._keyboard_cancellation:
+                self._keyboard_cancellation.stop_monitoring()
+                self._keyboard_cancellation = None
+            self._current_cancel_event = None
+
+
+# Global cancellation manager instance
+_global_manager = None
+
+
+def get_cancellation_manager() -> CancellationManager:
+    """Get the global cancellation manager instance."""
+    global _global_manager
+    if _global_manager is None:
+        _global_manager = CancellationManager()
+    return _global_manager

janito/llm/driver.py

@@ -252,3 +252,10 @@ class LLMDriver(ABC):
     def _get_message_from_result(self, result):
         """Extract the message object from the provider result. Subclasses must implement this."""
         raise NotImplementedError("Subclasses must implement _get_message_from_result.")
+
+    def cancel_current_request(self):
+        """Cancel the current request being processed."""
+        # Use global cancellation manager to cancel the current request
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        cancel_manager.cancel_current_request()

janito/llm/enter_cancellation.py

@@ -0,0 +1,93 @@
+"""
+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:
+            import sys
+            import select
+            import msvcrt  # Windows-specific keyboard input
+            
+            # Monitor for Enter key (Windows-specific implementation)
+            while self._listening and self._cancel_event and not self._cancel_event.is_set():
+                try:
+                    # Windows-specific: check if key is available
+                    if msvcrt.kbhit():
+                        char = msvcrt.getch()
+                        # Check for Enter key (carriage return or newline)
+                        if char in [b'\r', b'\n']:
+                            if self._cancel_event:
+                                self._cancel_event.set()
+                            break
+                        else:
+                            # Discard any other input
+                            pass
+                    else:
+                        # Small delay to prevent high CPU usage
+                        time.sleep(0.05)
+                        
+                except (IOError, OSError):
+                    break
+                except Exception:
+                    # Fallback to select-based approach for non-Windows
+                    try:
+                        if sys.stdin in select.select([sys.stdin], [], [], 0.05)[0]:
+                            char = sys.stdin.read(1)
+                            if char in ['\r', '\n']:  # Enter key
+                                if self._cancel_event:
+                                    self._cancel_event.set()
+                                break
+                    except:
+                        pass
+                    time.sleep(0.05)
+                
+        except Exception:
+            # Silently handle any errors
+            pass
+
+
+# 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/__init__.py

@@ -0,0 +1,10 @@
+"""
+Plugin System Core Package
+
+This package provides the foundational plugin system architecture.
+It should not depend on any specific plugin implementations.
+"""
+
+from .base import Plugin, PluginMetadata, PluginResource
+
+__all__ = ["Plugin", "PluginMetadata", "PluginResource"]

janito/{plugins → plugin_system}/base.py

@@ -5,7 +5,10 @@ Base classes for janito plugins.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Dict, Any, List, Optional, Type, Union
-from janito.tools.tool_base import ToolBase
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from janito.tools.tool_base import ToolBase
 
 
 @dataclass
@@ -50,7 +53,7 @@ class Plugin(ABC):
         """Return metadata describing this plugin."""
         pass
 
-    def get_tools(self) -> List[Type[ToolBase]]:
+    def get_tools(self) -> List[Type["ToolBase"]]:
         """
         Return a list of tool classes provided by this plugin.
 

janito/{plugins/core_loader_fixed.py → plugin_system/core_loader.py}

@@ -5,26 +5,27 @@ This module provides a working implementation to load core plugins
 by directly using the Plugin base class properly.
 """
 
+import importlib
 import importlib.util
 import sys
 from pathlib import Path
 from typing import Optional, List, Type
 
-from janito.plugins.base import Plugin, PluginMetadata
+from janito.plugin_system.base import Plugin, PluginMetadata
 from janito.tools.function_adapter import create_function_tool
 from janito.tools.tool_base import ToolBase
 
 
 class CorePlugin(Plugin):
     """Working core plugin implementation."""
-    
+
     def __init__(self, name: str, description: str, tools: list):
         self._plugin_name = name
         self._description = description
         self._tools = tools
         self._tool_classes = []
         super().__init__()  # Call super after setting attributes
-        
+
     def get_metadata(self) -> PluginMetadata:
         return PluginMetadata(
             name=self._plugin_name,
@@ -33,10 +34,10 @@ class CorePlugin(Plugin):
             author="Janito",
             license="MIT",
         )
-    
+
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
-    
+
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
@@ -49,10 +50,10 @@ class CorePlugin(Plugin):
 def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin by name.
-    
+
     Args:
         plugin_name: Name of the plugin (e.g., 'core.filemanager')
-        
+
     Returns:
         Plugin instance if loaded successfully
     """
@@ -60,49 +61,67 @@ def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
         # Parse plugin name
         if "." not in plugin_name:
             return None
-            
+
         parts = plugin_name.split(".")
         if len(parts) != 2:
             return None
-            
+
         package_name, submodule_name = parts
-        
+
         # Handle imagedisplay specially
         if plugin_name == "core.imagedisplay":
             # Import the actual plugin class
             try:
-                from plugins.core.imagedisplay.plugin import ImageDisplayPlugin
-                return ImageDisplayPlugin()
-            except ImportError:
-                # If import fails, return None - don't return True
+                # Use dynamic import to avoid circular dependency
+                plugin_module = importlib.import_module(
+                    "janito.plugins.core.imagedisplay.plugin"
+                )
+                return plugin_module.ImageDisplayPlugin()
+            except ImportError as e:
+                print(f"Failed to load imagedisplay: {e}")
                 return None
-        
+
         # Build path to plugin
-        plugin_path = Path("plugins") / package_name / submodule_name / "__init__.py"
+        plugin_path = (
+            Path("janito/plugins") / package_name / submodule_name / "__init__.py"
+        )
         if not plugin_path.exists():
             return None
-            
+
         # Load the module
         spec = importlib.util.spec_from_file_location(plugin_name, plugin_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 info
         name = 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}"
+        )
         tools = getattr(module, "__plugin_tools__", [])
-        
+
         if not tools:
             return None
-            
+
+        # Filter out None values and ensure all tools have tool_name
+        valid_tools = []
+        for tool in tools:
+            if tool is not None:
+                if not hasattr(tool, "tool_name"):
+                    tool.tool_name = tool.__name__
+                valid_tools.append(tool)
+
+        if not valid_tools:
+            return None
+
         # Create plugin
-        plugin = CorePlugin(name, description, tools)
+        plugin = CorePlugin(name, description, valid_tools)
         plugin.initialize()
         return plugin
-        
+
     except Exception as e:
         print(f"Error loading core plugin {plugin_name}: {e}")
         return None
@@ -120,6 +139,6 @@ def get_core_plugins() -> list:
         "ui.userinterface",
         "web.webtools",
     ]
-    
+
     # All core plugins are always available
-    return core_plugins
+    return core_plugins

janito/plugin_system/core_loader_fixed.py

@@ -0,0 +1,149 @@
+"""
+Fixed core plugin loader.
+
+This module provides a working implementation to load core plugins
+by directly using the Plugin base class properly.
+"""
+
+import importlib.util
+import sys
+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
+
+
+class CorePlugin(Plugin):
+    """Working core plugin implementation."""
+
+    def __init__(self, name: str, description: str, tools: list):
+        self._plugin_name = name
+        self._description = description
+        self._tools = tools
+        self._tool_classes = []
+        super().__init__()  # Call super after setting attributes
+
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name=self._plugin_name,
+            version="1.0.0",
+            description=self._description,
+            author="Janito",
+            license="MIT",
+        )
+
+    def get_tools(self) -> List[Type[ToolBase]]:
+        return self._tool_classes
+
+    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)
+                self._tool_classes.append(tool_class)
+
+
+def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
+    """
+    Load a core plugin by name.
+
+    Args:
+        plugin_name: Name of the plugin (e.g., 'core.filemanager')
+
+    Returns:
+        Plugin instance if loaded successfully
+    """
+    try:
+        # Parse plugin name
+        if "." not in plugin_name:
+            return None
+
+        parts = plugin_name.split(".")
+        if len(parts) != 2:
+            return None
+
+        package_name, submodule_name = parts
+
+        # Handle imagedisplay specially
+        if plugin_name == "core.imagedisplay":
+            # Import the actual plugin class
+            try:
+                from janito.plugins.core.imagedisplay.plugin import ImageDisplayPlugin
+
+                return ImageDisplayPlugin()
+            except ImportError as e:
+                print(f"Failed to load imagedisplay: {e}")
+                return None
+
+        # Build path to plugin
+        plugin_path = (
+            Path("janito/plugins") / package_name / submodule_name / "__init__.py"
+        )
+        if not plugin_path.exists():
+            return None
+
+        # Load the module
+        spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+
+        # Add module to sys.modules to prevent circular imports
+        sys.modules[plugin_name] = module
+
+        try:
+            # Read and execute the module content
+            with open(plugin_path, "r", encoding="utf-8") as f:
+                code = f.read()
+
+            # Execute in module's namespace
+            exec(code, module.__dict__)
+
+            # Get plugin info
+            name = module.__dict__.get("__plugin_name__", plugin_name)
+            description = module.__dict__.get(
+                "__plugin_description__", f"Core plugin: {plugin_name}"
+            )
+            tools = module.__dict__.get("__plugin_tools__", [])
+
+            if not tools:
+                return None
+
+            # Ensure all tools have tool_name attribute
+            for tool in tools:
+                if tool is not None and not hasattr(tool, "tool_name"):
+                    tool.tool_name = tool.__name__
+
+            # Create plugin
+            plugin = CorePlugin(name, description, tools)
+            plugin.initialize()
+            return plugin
+        finally:
+            # Clean up sys.modules
+            if plugin_name in sys.modules:
+                del sys.modules[plugin_name]
+
+    except Exception as e:
+        print(f"Error loading core plugin {plugin_name}: {e}")
+        return None
+
+
+def get_core_plugins() -> list:
+    """Get list of all available core plugins."""
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+        "ui.userinterface",
+        "web.webtools",
+    ]
+
+    # All core plugins are always available
+    return core_plugins

janito/plugins/__init__.py

@@ -1,17 +1,36 @@
 """
-Plugin system for janito.
+Plugin System for Development Tools
 
-This package provides a flexible plugin system that allows extending
-janito's functionality with custom tools, commands, and features.
+This package organizes all available tools into logical plugin groups
+for easier discovery and usage.
 """
 
-from .manager import PluginManager
-from .base import Plugin, PluginMetadata
-from .discovery import discover_plugins
+__version__ = "1.0.0"
+__author__ = "Development Assistant"
 
-__all__ = [
-    "PluginManager",
-    "Plugin",
-    "PluginMetadata",
-    "discover_plugins",
-]
+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/auto_loader_fixed.py

@@ -9,12 +9,12 @@ import os
 from pathlib import Path
 from typing import List
 from janito.plugins.manager import PluginManager
-from janito.plugins.core_loader_fixed import load_core_plugin, get_core_plugins
+from janito.plugin_system.core_loader_fixed import load_core_plugin, get_core_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",
@@ -27,18 +27,18 @@ 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()
-    
+
     loaded = []
-    
+
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -49,14 +49,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
     """
@@ -68,10 +68,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
     """
@@ -81,10 +81,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 janito.plugins.base import Plugin
+from janito.plugin_system.base import Plugin
 
 
 class BuiltinPluginRegistry:
@@ -83,6 +83,20 @@ try:
         "documentation_generator", DocumentationGeneratorPlugin
     )
 
+    # Register core tools plugin
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+
 except ImportError:
     # janito-coder not available, skip registration
     pass
+
+# Register core tools plugin (always available)
+try:
+    from janito.plugins.tools import CoreToolsPlugin
+
+    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
+except ImportError:
+    # Should not happen, but handle gracefully
+    pass

janito/plugins/core/__init__.py

@@ -0,0 +1,7 @@
+"""
+Core Plugin Package
+
+Contains essential system and file management plugins.
+"""
+
+__all__ = ["filemanager", "codeanalyzer", "system"]