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

janito/cli/cli_commands/check_tools.py

@@ -1,212 +0,0 @@
-"""
-CLI Command: Check all registered tools for signature validation and availability
-"""
-
-import inspect
-import sys
-from typing import Dict, List, Tuple, Any
-
-
-def _validate_tool_signature(tool_instance) -> Tuple[bool, List[str]]:
-    """Validate the signature of a tool's run method."""
-    errors = []
-
-    if not hasattr(tool_instance, "run"):
-        errors.append("Missing 'run' method")
-        return False, errors
-
-    try:
-        sig = inspect.signature(tool_instance.run)
-    except ValueError as e:
-        errors.append(f"Invalid signature: {e}")
-        return False, errors
-
-    # Basic signature validation - just check if it's callable
-    if not callable(getattr(tool_instance, "run")):
-        errors.append("'run' method is not callable")
-
-    return len(errors) == 0, errors
-
-
-def _check_tool_availability(tool_instance) -> Tuple[bool, List[str]]:
-    """Check if a tool is available for use."""
-    errors = []
-
-    # Check if tool has required attributes
-    required_attrs = ["tool_name"]
-    for attr in required_attrs:
-        if not hasattr(tool_instance, attr):
-            errors.append(f"Missing required attribute: {attr}")
-
-    # Check description (optional for now)
-    if not hasattr(tool_instance, "description"):
-        pass  # Allow missing description
-
-    # Check permissions
-    if not hasattr(tool_instance, "permissions"):
-        # Function-based tools use permissions from function decorators
-        pass  # Allow missing permissions for function-based tools
-    else:
-        perms = tool_instance.permissions
-        if (
-            not hasattr(perms, "read")
-            or not hasattr(perms, "write")
-            or not hasattr(perms, "execute")
-        ):
-            errors.append("Invalid permissions structure")
-
-    return len(errors) == 0, errors
-
-
-def _get_tool_status_summary(
-    tools: List[Any], disabled_tools: List[str]
-) -> Dict[str, Any]:
-    """Get a comprehensive status summary for all tools."""
-    summary = {
-        "total": len(tools),
-        "available": 0,
-        "disabled": 0,
-        "invalid": 0,
-        "details": [],
-    }
-
-    for tool in tools:
-        tool_name = getattr(tool, "tool_name", str(tool))
-
-        # Check if disabled
-        is_disabled = tool_name in disabled_tools
-
-        # Validate signature and availability
-        sig_valid, sig_errors = _validate_tool_signature(tool)
-        avail_valid, avail_errors = _check_tool_availability(tool)
-
-        status = {
-            "name": tool_name,
-            "disabled": is_disabled,
-            "signature_valid": sig_valid,
-            "available": avail_valid,
-            "signature_errors": sig_errors,
-            "availability_errors": avail_errors,
-        }
-
-        summary["details"].append(status)
-
-        if is_disabled:
-            summary["disabled"] += 1
-        elif not sig_valid or not avail_valid:
-            summary["invalid"] += 1
-        else:
-            summary["available"] += 1
-
-    return summary
-
-
-def _print_check_results(console, summary: Dict[str, Any], verbose: bool = False):
-    """Print the tool check results in a formatted way."""
-    from rich.table import Table
-    from rich.panel import Panel
-    from rich.text import Text
-
-    # Overall summary
-    summary_text = Text()
-    summary_text.append(f"Total tools: {summary['total']}", style="cyan")
-    summary_text.append(" | ")
-    summary_text.append(f"Available: {summary['available']}", style="green")
-    summary_text.append(" | ")
-    summary_text.append(f"Disabled: {summary['disabled']}", style="yellow")
-    summary_text.append(" | ")
-    summary_text.append(f"Invalid: {summary['invalid']}", style="red")
-
-    console.print(Panel(summary_text, title="Tool Check Summary", style="bold"))
-
-    # Always show the table for check-tools
-    table = Table(title="Tool Details", show_header=True, header_style="bold")
-    table.add_column("Tool", style="cyan", no_wrap=True)
-    table.add_column("Status", style="green")
-    table.add_column("Issues", style="red")
-
-    for detail in summary["details"]:
-        name = detail["name"]
-
-        if detail["disabled"]:
-            status = "[yellow]Disabled[/yellow]"
-            issues = "-"
-        elif not detail["available"] or not detail["signature_valid"]:
-            status = "[red]Invalid[/red]"
-            all_issues = detail["signature_errors"] + detail["availability_errors"]
-            issues = "\n".join(all_issues)
-        else:
-            status = "[green]Available[/green]"
-            issues = "-"
-
-        table.add_row(name, status, issues)
-
-    console.print(table)
-
-
-def handle_check_tools(args=None):
-    """Handle the --check-tools CLI command."""
-    from janito.tools.adapters.local.adapter import LocalToolsAdapter
-    import janito.tools  # Ensure all tools are registered
-
-    # Load disabled tools from config
-    from janito.tools.disabled_tools import DisabledToolsState
-    from janito.config import config
-
-    disabled_str = config.get("disabled_tools", "")
-    if disabled_str:
-        DisabledToolsState.set_disabled_tools(disabled_str)
-    disabled_tools = DisabledToolsState.get_disabled_tools()
-
-    # Initialize tools properly using the same approach as list_tools.py
-    from janito.tools.adapters.local.adapter import LocalToolsAdapter
-    from janito.tools.tool_base import ToolPermissions
-    import janito.tools  # Ensure all tools are registered
-
-    read = getattr(args, "read", False) if args else False
-    write = getattr(args, "write", False) if args else False
-    execute = getattr(args, "exec", False) if args else False
-    if not (read or write or execute):
-        read = write = execute = True
-    from janito.tools.permissions import set_global_allowed_permissions
-
-    set_global_allowed_permissions(
-        ToolPermissions(read=read, write=write, execute=execute)
-    )
-
-    # Load disabled tools from config
-    from janito.tools.disabled_tools import DisabledToolsState
-    from janito.config import config
-
-    disabled_str = config.get("disabled_tools", "")
-    if disabled_str:
-        DisabledToolsState.set_disabled_tools(disabled_str)
-    disabled_tools = DisabledToolsState.get_disabled_tools()
-
-    # Initialize tools using the same method as list_tools.py
-    from janito.tools.initialize import initialize_tools
-
-    registry = initialize_tools()
-
-    # Get actual tool instances
-    tool_instances = []
-    for name, tool_info in registry._tools.items():
-        if "instance" in tool_info:
-            tool_instances.append(tool_info["instance"])
-
-    if not tool_instances:
-        print("No tools registered.")
-        return
-
-    from rich.console import Console
-
-    console = Console()
-
-    verbose = getattr(args, "verbose", False) if args else False
-
-    summary = _get_tool_status_summary(tool_instances, disabled_tools)
-    _print_check_results(console, summary, verbose=verbose)
-
-    # Exit with error code if there are invalid tools
-    if summary["invalid"] > 0:
-        sys.exit(1)

janito/llm/cancellation_manager.py

@@ -1,63 +0,0 @@
-"""
-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/enter_cancellation.py

@@ -1,107 +0,0 @@
-"""
-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/__init__.py

@@ -1,10 +0,0 @@
-"""
-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/plugin_system/core_loader.py

@@ -1,217 +0,0 @@
-"""
-Fixed core plugin loader.
-
-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.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.tool_base import ToolBase, ToolPermissions
-
-
-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 _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 = self._create_tool_class(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:
-                # 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("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}"
-        )
-        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, valid_tools)
-        plugin.initialize()
-        return plugin
-
-    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