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

janito/README.md

@@ -106,6 +106,9 @@ janito --set model=kimi-k1-8k
 
 ## Advanced Features
 
+### 🚀 New in v3.1.0: Enter Key Cancellation
+**Chat Mode Enhancement**: Press **Enter** at any time to instantly cancel long-running requests in interactive chat mode. No more waiting for stuck requests!
+
 ### Tool Usage
 
 Janito includes powerful built-in tools for:

janito/cli/chat_mode/bindings.py

@@ -35,4 +35,54 @@ class KeyBindingsFactory:
             buf.text = "Do It"
             buf.validate_and_handle()
 
+        @bindings.add("c-c")
+        def _(event):
+            """Handle Ctrl+C to interrupt current request or exit chat."""
+            # Use global cancellation manager for robust cancellation
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+
+            cancelled = cancel_manager.cancel_current_request()
+            if cancelled:
+                # Provide user feedback
+                from rich.console import Console
+
+                console = Console()
+                console.print("[red]Request cancelled by Ctrl+C[/red]")
+
+                # Prevent the Ctrl+C from being processed as input
+                event.app.output.flush()
+                return
+            else:
+                # No active request to cancel, exit the chat
+                from rich.console import Console
+                console = Console()
+                console.print("[yellow]Goodbye![/yellow]")
+                event.app.exit()
+
+        @bindings.add("escape", eager=True)
+        def _(event):
+            """Handle ESC key to interrupt current request (like Ctrl+C)."""
+            import threading
+
+            # Use global cancellation manager for robust cancellation
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+
+            cancelled = cancel_manager.cancel_current_request()
+            if cancelled:
+                # Provide user feedback
+                from rich.console import Console
+
+                console = Console()
+                console.print("[red]Request cancelled by ESC key[/red]")
+
+                # Prevent the ESC key from being processed as input
+                event.app.output.flush()
+                return
+
+            # If no active request to cancel, ESC does nothing
+
         return bindings

janito/cli/chat_mode/session.py

@@ -22,6 +22,7 @@ import time
 
 # Shared prompt/agent factory
 from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+from janito.llm.cancellation_manager import get_cancellation_manager
 
 import time
 
@@ -113,6 +114,10 @@ class ChatSession:
 
         # Check if multi-line mode should be enabled by default
         self.multi_line_mode = getattr(args, "multi", False) if args else False
+        
+        # Default to single-line mode (Enter submits) unless explicitly enabled
+        if not self.multi_line_mode:
+            self.multi_line_mode = False
 
     def _select_profile_and_role(self, args, role):
         profile, role_arg, python_profile, market_profile = self._extract_args(args)
@@ -283,7 +288,13 @@ class ChatSession:
                 )
             )
 
-            self._prompt_handler.run_prompt(cmd_input)
+            try:
+                self._prompt_handler.run_prompt(cmd_input)
+            finally:
+                # Ensure cancellation manager is cleared
+                cancel_manager = get_cancellation_manager()
+                cancel_manager.clear_current_request()
+
             end_time = time.time()
             elapsed = end_time - start_time
             self.msg_count += 1

janito/cli/chat_mode/shell/commands/multi.py

@@ -23,6 +23,11 @@ class MultiShellHandler(ShellCmdHandler):
             submitted["value"] = buffer.text
             event.app.exit(result=buffer.text)
 
+        # Support single ESC to cancel/interrupt (like Ctrl+C)
+        @bindings.add("escape")
+        def _(event):
+            raise KeyboardInterrupt
+
         # Support Ctrl+D
         @bindings.add("c-d")
         def _(event):

janito/cli/chat_mode/shell/commands/security/allowed_sites.py

@@ -59,39 +59,53 @@ Examples:
         command = args[0].lower()
         whitelist_manager = get_url_whitelist_manager()
 
-        if command == "list":
-            sites = whitelist_manager.get_allowed_sites()
-            if sites:
-                print("Allowed sites:")
-                for site in sites:
-                    print(f"  • {site}")
-            else:
-                print("No sites are whitelisted (all sites are allowed)")
-
-        elif command == "add":
-            if len(args) < 2:
-                print("Error: Please specify a site to add")
-                return
-            site = args[1]
-            if whitelist_manager.add_allowed_site(site):
-                print(f"✅ Added '{site}' to allowed sites")
-            else:
-                print(f"ℹ️ '{site}' is already in allowed sites")
-
-        elif command == "remove":
-            if len(args) < 2:
-                print("Error: Please specify a site to remove")
-                return
-            site = args[1]
-            if whitelist_manager.remove_allowed_site(site):
-                print(f"✅ Removed '{site}' from allowed sites")
-            else:
-                print(f"ℹ️ '{site}' was not in allowed sites")
-
-        elif command == "clear":
-            whitelist_manager.clear_whitelist()
-            print("✅ Cleared all allowed sites (all sites are now allowed)")
-
+        handlers = {
+            "list": self._handle_list,
+            "add": self._handle_add,
+            "remove": self._handle_remove,
+            "clear": self._handle_clear,
+        }
+
+        handler = handlers.get(command)
+        if handler:
+            handler(args, whitelist_manager)
         else:
             print(f"Error: Unknown command '{command}'")
             print(self.get_usage())
+
+    def _handle_list(self, args, whitelist_manager):
+        """Handle list command."""
+        sites = whitelist_manager.get_allowed_sites()
+        if sites:
+            print("Allowed sites:")
+            for site in sites:
+                print(f"  • {site}")
+        else:
+            print("No sites are whitelisted (all sites are allowed)")
+
+    def _handle_add(self, args, whitelist_manager):
+        """Handle add command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to add")
+            return
+        site = args[1]
+        if whitelist_manager.add_allowed_site(site):
+            print(f"✅ Added '{site}' to allowed sites")
+        else:
+            print(f"ℹ️ '{site}' is already in allowed sites")
+
+    def _handle_remove(self, args, whitelist_manager):
+        """Handle remove command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to remove")
+            return
+        site = args[1]
+        if whitelist_manager.remove_allowed_site(site):
+            print(f"✅ Removed '{site}' from allowed sites")
+        else:
+            print(f"ℹ️ '{site}' was not in allowed sites")
+
+    def _handle_clear(self, args, whitelist_manager):
+        """Handle clear command."""
+        whitelist_manager.clear_whitelist()
+        print("✅ Cleared all allowed sites (all sites are now allowed)")

janito/cli/cli_commands/check_tools.py

@@ -0,0 +1,212 @@
+"""
+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/cli/cli_commands/list_plugins.py

@@ -8,7 +8,11 @@ from janito.plugins.discovery import list_available_plugins
 import os
 from janito.plugins.manager import PluginManager
 from janito.plugins.builtin import BuiltinPluginRegistry
-from janito.plugins.auto_loader_fixed import load_core_plugins, get_loaded_core_plugins, is_core_plugin
+from janito.plugins.auto_loader_fixed import (
+    load_core_plugins,
+    get_loaded_core_plugins,
+    is_core_plugin,
+)
 from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
@@ -51,7 +55,8 @@ def _list_available_plugins():
         console.print(table)
 
         # Show core plugins
-        from janito.plugins.core_loader_fixed import get_core_plugins
+        from janito.plugin_system.core_loader_fixed import get_core_plugins
+
         core_plugins = get_core_plugins()
         core_table = Table(title="Core Plugins (Enabled by Default)")
         core_table.add_column("Plugin Name", style="cyan", no_wrap=True)
@@ -62,14 +67,16 @@ def _list_available_plugins():
 
         console.print(core_table)
     else:
-        console.print(Panel(
-            "No plugins found in search paths\n"
-            f"[dim]Search paths:[/dim]\n"
-            f"  • {os.getcwd()}/plugins\n"
-            f"  • {os.path.expanduser('~')}/.janito/plugins",
-            title="No Plugins Found",
-            style="yellow"
-        ))
+        console.print(
+            Panel(
+                "No plugins found in search paths\n"
+                f"[dim]Search paths:[/dim]\n"
+                f"  • {os.getcwd()}/plugins\n"
+                f"  • {os.path.expanduser('~')}/.janito/plugins",
+                title="No Plugins Found",
+                style="yellow",
+            )
+        )
 
 
 def _print_builtin_plugins(builtin_plugins):
@@ -92,7 +99,7 @@ def _print_external_plugins(available, builtin_plugins):
 def _list_plugin_resources():
     """List all resources from loaded plugins using rich formatting."""
     from janito.plugins.auto_loader_fixed import get_plugin_manager
-    
+
     console = Console()
     manager = get_plugin_manager()
     all_resources = manager.list_all_resources()
@@ -100,11 +107,11 @@ def _list_plugin_resources():
     if all_resources:
         for plugin_name, resources in all_resources.items():
             metadata = manager.get_plugin_metadata(plugin_name)
-            version = metadata.version if metadata else 'unknown'
-            
+            version = metadata.version if metadata else "unknown"
+
             # Create panel for each plugin
             panel_content = []
-            
+
             tools = [r for r in resources if r["type"] == "tool"]
             commands = [r for r in resources if r["type"] == "command"]
             configs = [r for r in resources if r["type"] == "config"]
@@ -122,19 +129,25 @@ def _list_plugin_resources():
             if configs:
                 panel_content.append("[bold yellow]Configuration:[/bold yellow]")
                 for config in configs:
-                    panel_content.append(f"  • {config['name']}: {config['description']}")
-
-            console.print(Panel(
-                "\n".join(panel_content),
-                title=f"{plugin_name} v{version}",
-                style="cyan"
-            ))
+                    panel_content.append(
+                        f"  • {config['name']}: {config['description']}"
+                    )
+
+            console.print(
+                Panel(
+                    "\n".join(panel_content),
+                    title=f"{plugin_name} v{version}",
+                    style="cyan",
+                )
+            )
     else:
-        console.print(Panel(
-            "No plugins are currently loaded.",
-            title="No Plugin Resources",
-            style="yellow"
-        ))
+        console.print(
+            Panel(
+                "No plugins are currently loaded.",
+                title="No Plugin Resources",
+                style="yellow",
+            )
+        )
 
 
 def _print_resources_by_type(resources):
@@ -162,7 +175,7 @@ def _print_resources_by_type(resources):
 def _list_loaded_plugins():
     """List loaded plugins using rich formatting."""
     from janito.plugins.auto_loader_fixed import get_plugin_manager
-    
+
     console = Console()
     manager = get_plugin_manager()
     loaded = manager.list_plugins()
@@ -177,42 +190,38 @@ def _list_loaded_plugins():
 
         core_plugins = []
         other_plugins = []
-        
+
         for plugin_name in loaded:
             if is_core_plugin(plugin_name):
                 core_plugins.append(plugin_name)
             else:
                 other_plugins.append(plugin_name)
-        
+
         # Add core plugins
         for plugin_name in core_plugins:
             metadata = manager.get_plugin_metadata(plugin_name)
             if metadata:
                 table.add_row(
-                    metadata.name,
-                    metadata.version,
-                    metadata.description,
-                    "🔵 Core"
+                    metadata.name, metadata.version, metadata.description, "🔵 Core"
                 )
-        
+
         # Add other plugins
         for plugin_name in other_plugins:
             metadata = manager.get_plugin_metadata(plugin_name)
             if metadata:
                 table.add_row(
-                    metadata.name,
-                    metadata.version,
-                    metadata.description,
-                    "🔶 External"
+                    metadata.name, metadata.version, metadata.description, "🔶 External"
                 )
 
         console.print(table)
     else:
-        console.print(Panel(
-            "No plugins are currently loaded.",
-            title="No Plugins Loaded",
-            style="yellow"
-        ))
+        console.print(
+            Panel(
+                "No plugins are currently loaded.",
+                title="No Plugins Loaded",
+                style="yellow",
+            )
+        )
 
 
 def _print_plugin_details(manager, plugin_name):

janito/cli/core/getters.py

@@ -5,6 +5,7 @@ import sys
 from janito.cli.cli_commands.list_providers import handle_list_providers
 from janito.cli.cli_commands.list_models import handle_list_models
 from janito.cli.cli_commands.list_tools import handle_list_tools
+from janito.cli.cli_commands.check_tools import handle_check_tools
 from janito.cli.cli_commands.show_config import handle_show_config
 from janito.cli.cli_commands.list_config import handle_list_config
 from janito.cli.cli_commands.list_drivers import handle_list_drivers
@@ -28,6 +29,7 @@ GETTER_KEYS = [
     "list_plugins",
     "list_plugins_available",
     "list_resources",
+    "check_tools",
 ]
 
 
@@ -64,6 +66,7 @@ def handle_getter(args, config_mgr=None):
         "list_plugins": partial(handle_list_plugins, args),
         "list_plugins_available": partial(handle_list_plugins, args),
         "list_resources": partial(handle_list_plugins, args),
+        "check_tools": partial(handle_check_tools, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/core/model_guesser.py

@@ -21,34 +21,50 @@ def guess_provider_from_model(model_name: str) -> str:
     model_name = model_name.lower()
 
     # Check each provider's models
+    return _find_provider_for_model(model_name)
+
+
+def _find_provider_for_model(model_name: str) -> str:
+    """Find provider for given model name."""
     for provider_name in LLMProviderRegistry.list_providers():
         provider_class = LLMProviderRegistry.get(provider_name)
         if not provider_class:
             continue
 
-        # Get model specs for this provider
-        try:
-            if hasattr(provider_class, "MODEL_SPECS"):
-                model_specs = provider_class.MODEL_SPECS
-                for spec_model_name in model_specs.keys():
-                    if spec_model_name.lower() == model_name:
-                        return provider_name
-
-            # Handle special cases like moonshot
-            if provider_name == "moonshot":
-                try:
-                    from janito.providers.moonshot.model_info import (
-                        MOONSHOT_MODEL_SPECS,
-                    )
-
-                    for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
-                        if spec_model_name.lower() == model_name:
-                            return "moonshot"
-                except ImportError:
-                    pass
-
-        except Exception:
-            # Skip providers that have issues accessing model specs
-            continue
+        if _check_provider_models(provider_name, provider_class, model_name):
+            return provider_name
 
     return None
+
+
+def _check_provider_models(provider_name: str, provider_class, model_name: str) -> bool:
+    """Check if provider has matching model."""
+    try:
+        if hasattr(provider_class, "MODEL_SPECS"):
+            model_specs = provider_class.MODEL_SPECS
+            for spec_model_name in model_specs.keys():
+                if spec_model_name.lower() == model_name:
+                    return True
+
+        # Handle special cases like moonshot
+        if provider_name == "moonshot":
+            return _check_moonshot_models(model_name)
+
+    except Exception:
+        # Skip providers that have issues accessing model specs
+        pass
+
+    return False
+
+
+def _check_moonshot_models(model_name: str) -> bool:
+    """Check moonshot models specifically."""
+    try:
+        from janito.providers.moonshot.model_info import MOONSHOT_MODEL_SPECS
+
+        for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
+            if spec_model_name.lower() == model_name:
+                return True
+    except ImportError:
+        pass
+    return False