janito 2.27.1__py3-none-any.whl → 2.29.0__py3-none-any.whl

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

@@ -1,18 +1,20 @@
 """Security command group for chat mode."""
 
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler as BaseCommand
-from janito.cli.chat_mode.shell.commands.security.allowed_sites import SecurityAllowedSitesCommand
+from janito.cli.chat_mode.shell.commands.security.allowed_sites import (
+    SecurityAllowedSitesCommand,
+)
 
 
 class SecurityCommand(BaseCommand):
     """Security management command group."""
-    
+
     def get_name(self) -> str:
         return "security"
-    
+
     def get_description(self) -> str:
         return "Security management commands"
-    
+
     def get_usage(self):
         return """
 Usage: /security <subcommand> [args...]
@@ -25,21 +27,23 @@ Examples:
   /security allowed-sites add tradingview.com
   /security allowed-sites remove yahoo.com
 """
-    
+
     def __init__(self, after_cmd_line=None, shell_state=None):
         super().__init__(after_cmd_line=after_cmd_line, shell_state=shell_state)
         self.subcommands = {
-            "allowed-sites": SecurityAllowedSitesCommand(after_cmd_line=after_cmd_line, shell_state=shell_state)
+            "allowed-sites": SecurityAllowedSitesCommand(
+                after_cmd_line=after_cmd_line, shell_state=shell_state
+            )
         }
-    
+
     def run(self):
         """Execute the security command."""
         args = self.after_cmd_line.strip().split()
-        
+
         if not args:
             print(self.get_usage())
             return
-            
+
         subcommand = args[0].lower()
         if subcommand in self.subcommands:
             # Pass the remaining args to the subcommand
@@ -48,4 +52,4 @@ Examples:
             self.subcommands[subcommand].run()
         else:
             print(f"Error: Unknown security subcommand '{subcommand}'")
-            print(self.get_usage())
+            print(self.get_usage())

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

@@ -56,8 +56,10 @@ class ToolsShellHandler(ShellCmdHandler):
 
     def run(self):
         # Check for no_tools_mode in shell_state
-        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
-            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+        if self.shell_state and getattr(self.shell_state, "no_tools_mode", False):
+            shared_console.print(
+                "[yellow]No tools are available in this mode (no tools, no context).[/yellow]"
+            )
             return
         try:
             import janito.tools  # Ensure all tools are registered

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

@@ -6,7 +6,7 @@ from janito.cli.console import shared_console
 
 class UnrestrictedShellHandler(ShellCmdHandler):
     """Toggle unrestricted mode (equivalent to -u CLI flag)."""
-    
+
     help_text = "Toggle unrestricted mode (disable path security and URL whitelist)"
 
     def run(self):
@@ -14,27 +14,32 @@ class UnrestrictedShellHandler(ShellCmdHandler):
         if not self.shell_state:
             shared_console.print("[red]Error: Shell state not available[/red]")
             return
-            
+
         # Toggle unrestricted mode
-        current_unrestricted = getattr(self.shell_state, 'unrestricted_mode', False)
+        current_unrestricted = getattr(self.shell_state, "unrestricted_mode", False)
         new_unrestricted = not current_unrestricted
-        
+
         # Update shell state
         self.shell_state.unrestricted_mode = new_unrestricted
-        
+
         # Update tools adapter
-        if hasattr(self.shell_state, 'tools_adapter'):
-            setattr(self.shell_state.tools_adapter, 'unrestricted_paths', new_unrestricted)
-            
+        if hasattr(self.shell_state, "tools_adapter"):
+            setattr(
+                self.shell_state.tools_adapter, "unrestricted_paths", new_unrestricted
+            )
+
         # Update URL whitelist manager
         from janito.tools.url_whitelist import get_url_whitelist_manager
+
         whitelist_manager = get_url_whitelist_manager()
         whitelist_manager.set_unrestricted_mode(new_unrestricted)
-        
+
         status = "enabled" if new_unrestricted else "disabled"
-        warning = " (DANGEROUS - no path or URL restrictions)" if new_unrestricted else ""
-        
+        warning = (
+            " (DANGEROUS - no path or URL restrictions)" if new_unrestricted else ""
+        )
+
         shared_console.print(
             f"[bold {'red' if new_unrestricted else 'green'}]"
             f"Unrestricted mode {status}{warning}[/bold {'red' if new_unrestricted else 'green'}]"
-        )
+        )

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

@@ -6,8 +6,10 @@ class WriteShellHandler(ShellCmdHandler):
     help_text = "/write on|off: Enable or disable write permissions for tools. Usage: /write on or /write off."
 
     def run(self):
-        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
-            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+        if self.shell_state and getattr(self.shell_state, "no_tools_mode", False):
+            shared_console.print(
+                "[yellow]No tools are available in this mode (no tools, no context).[/yellow]"
+            )
             return
         if not self.shell_state:
             shared_console.print("[red]Shell state unavailable.[/red]")

janito/cli/chat_mode/toolbar.py

@@ -20,17 +20,17 @@ def format_tokens(n, tag=None):
 def assemble_first_line(provider_name, model_name, role, agent=None):
     cwd = os.getcwd()
     home = os.path.expanduser("~")
-    
+
     # Convert to relative path if under home directory
     if cwd.startswith(home):
-        cwd_display = "~" + cwd[len(home):]
+        cwd_display = "~" + cwd[len(home) :]
     else:
         cwd_display = cwd
-    
+
     # Shorten long paths for display
     if len(cwd_display) > 50:
         cwd_display = "..." + cwd_display[-47:]
-    
+
     return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Dir: <model>{cwd_display}</model>"
 
 

janito/cli/cli_commands/enable_disable_plugin.py

@@ -6,25 +6,33 @@ import argparse
 import json
 from pathlib import Path
 from typing import Dict, Any
-from janito.plugins.config import load_plugins_config, save_plugins_config, get_plugins_config_path
+from janito.plugins.config import (
+    load_plugins_config,
+    save_plugins_config,
+    get_plugins_config_path,
+)
 from janito.plugins.manager import PluginManager
 
 
 def handle_enable_plugin(args: argparse.Namespace) -> None:
     """Enable a plugin by adding it to plugins.json."""
     config = load_plugins_config()
-    
-    if 'plugins' not in config:
-        config['plugins'] = {}
-    if 'load' not in config['plugins']:
-        config['plugins']['load'] = {}
-    
+
+    if "plugins" not in config:
+        config["plugins"] = {}
+    if "load" not in config["plugins"]:
+        config["plugins"]["load"] = {}
+
     # Set the plugin to enabled (True)
-    config['plugins']['load'][args.plugin_name] = True
-    
+    config["plugins"]["load"][args.plugin_name] = True
+
     if save_plugins_config(config):
-        print(f"Plugin '{args.plugin_name}' has been enabled in {get_plugins_config_path()}")
-        print("Note: You may need to reload the plugin in the current session with 'plugin reload'")
+        print(
+            f"Plugin '{args.plugin_name}' has been enabled in {get_plugins_config_path()}"
+        )
+        print(
+            "Note: You may need to reload the plugin in the current session with 'plugin reload'"
+        )
     else:
         print(f"Error: Failed to enable plugin '{args.plugin_name}'")
 
@@ -32,33 +40,48 @@ def handle_enable_plugin(args: argparse.Namespace) -> None:
 def handle_disable_plugin(args: argparse.Namespace) -> None:
     """Disable a plugin by removing it from plugins.json or setting it to False."""
     config = load_plugins_config()
-    
-    if 'plugins' in config and 'load' in config['plugins'] and args.plugin_name in config['plugins']['load']:
+
+    if (
+        "plugins" in config
+        and "load" in config["plugins"]
+        and args.plugin_name in config["plugins"]["load"]
+    ):
         # Remove the plugin entry or set it to False
         if args.remove:
-            del config['plugins']['load'][args.plugin_name]
+            del config["plugins"]["load"][args.plugin_name]
             action = "removed"
         else:
-            config['plugins']['load'][args.plugin_name] = False
+            config["plugins"]["load"][args.plugin_name] = False
             action = "disabled"
-        
+
         if save_plugins_config(config):
-            print(f"Plugin '{args.plugin_name}' has been {action} in {get_plugins_config_path()}")
-            print("Note: You may need to unload the plugin in the current session with 'plugin unload'")
+            print(
+                f"Plugin '{args.plugin_name}' has been {action} in {get_plugins_config_path()}"
+            )
+            print(
+                "Note: You may need to unload the plugin in the current session with 'plugin unload'"
+            )
         else:
             print(f"Error: Failed to {action} plugin '{args.plugin_name}'")
     else:
-        print(f"Plugin '{args.plugin_name}' is not currently configured in plugins.json")
-        print("It may still be loaded in the current session, but won't be loaded on restart")
+        print(
+            f"Plugin '{args.plugin_name}' is not currently configured in plugins.json"
+        )
+        print(
+            "It may still be loaded in the current session, but won't be loaded on restart"
+        )
 
 
 def add_enable_plugin_args(parser: argparse.ArgumentParser) -> None:
     """Add enable-plugin arguments to argument parser."""
-    parser.add_argument('plugin_name', help='Name of the plugin to enable')
-    
+    parser.add_argument("plugin_name", help="Name of the plugin to enable")
+
 
 def add_disable_plugin_args(parser: argparse.ArgumentParser) -> None:
     """Add disable-plugin arguments to argument parser."""
-    parser.add_argument('plugin_name', help='Name of the plugin to disable')
-    parser.add_argument('--remove', action='store_true', 
-                       help='Completely remove the plugin from config instead of setting to False')
+    parser.add_argument("plugin_name", help="Name of the plugin to disable")
+    parser.add_argument(
+        "--remove",
+        action="store_true",
+        help="Completely remove the plugin from config instead of setting to False",
+    )

janito/cli/cli_commands/list_models.py

@@ -30,10 +30,10 @@ def handle_list_models(args, provider_instance):
             # Fallback for simple string model lists
             from rich.table import Table
             from janito.cli.console import shared_console
-            
+
             table = Table(title=f"Supported models for provider '{provider_name}'")
             table.add_column("Model Name", style="cyan")
-            
+
             for m in models:
                 table.add_row(str(m))
             if sys.stdout.isatty():

janito/cli/cli_commands/list_plugins.py

@@ -12,21 +12,21 @@ from janito.plugins.builtin import BuiltinPluginRegistry
 
 def handle_list_plugins(args: argparse.Namespace) -> None:
     """List plugins command handler."""
-    
-    if getattr(args, 'list_plugins_available', False):
+
+    if getattr(args, "list_plugins_available", False):
         # List available plugins
         available = list_available_plugins()
         builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
-        
+
         if available or builtin_plugins:
             print("Available plugins:")
-            
+
             # Show builtin plugins first
             if builtin_plugins:
                 print("  Builtin plugins:")
                 for plugin in builtin_plugins:
                     print(f"    - {plugin} [BUILTIN]")
-            
+
             # Show other available plugins
             other_plugins = [p for p in available if p not in builtin_plugins]
             if other_plugins:
@@ -38,32 +38,34 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
             print("Search paths:")
             print(f"  - {os.getcwd()}/plugins")
             print(f"  - {os.path.expanduser('~')}/.janito/plugins")
-    elif getattr(args, 'list_resources', False):
+    elif getattr(args, "list_resources", False):
         # List all resources from loaded plugins
         manager = PluginManager()
         all_resources = manager.list_all_resources()
-        
+
         if all_resources:
             print("Plugin Resources:")
             for plugin_name, resources in all_resources.items():
                 metadata = manager.get_plugin_metadata(plugin_name)
-                print(f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:")
-                
+                print(
+                    f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:"
+                )
+
                 # Group resources by type
-                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']
-                
+                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"]
+
                 if tools:
                     print("  Tools:")
                     for tool in tools:
                         print(f"    - {tool['name']}: {tool['description']}")
-                
+
                 if commands:
                     print("  Commands:")
                     for cmd in commands:
                         print(f"    - {cmd['name']}: {cmd['description']}")
-                
+
                 if configs:
                     print("  Configuration:")
                     for config in configs:
@@ -74,7 +76,7 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
         # List loaded plugins
         manager = PluginManager()
         loaded = manager.list_plugins()
-        
+
         if loaded:
             print("Loaded plugins:")
             for plugin_name in loaded:
@@ -89,5 +91,3 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
                     print()
         else:
             print("No plugins loaded")
-
-

janito/cli/cli_commands/list_profiles.py

@@ -19,13 +19,13 @@ def _extract_profile_name(filename: str) -> str:
         filename = filename[len(_PREFIX) :]
     if filename.endswith(_SUFFIX):
         filename = filename[: -len(_SUFFIX)]
-    
+
     # Convert to title case for consistent capitalization, but handle common acronyms
     name = filename.replace("_", " ")
-    
+
     # Convert to proper title case with consistent capitalization
     name = filename.replace("_", " ")
-    
+
     # Handle special cases and acronyms
     special_cases = {
         "python": "Python",
@@ -35,9 +35,9 @@ def _extract_profile_name(filename: str) -> str:
         "developer": "Developer",
         "analyst": "Analyst",
         "conversation": "Conversation",
-        "without": "Without"
+        "without": "Without",
     }
-    
+
     words = name.split()
     capitalized_words = []
     for word in words:
@@ -46,7 +46,7 @@ def _extract_profile_name(filename: str) -> str:
             capitalized_words.append(special_cases[lower_word])
         else:
             capitalized_words.append(word.capitalize())
-    
+
     return " ".join(capitalized_words)
 
 

janito/cli/cli_commands/list_providers.py

@@ -8,7 +8,7 @@ from janito.cli.cli_commands.ping_providers import handle_ping_providers
 
 def handle_list_providers(args=None):
     # Check if ping flag is set
-    if args and getattr(args, 'ping', False):
+    if args and getattr(args, "ping", False):
         handle_ping_providers(args)
     else:
         list_providers()

janito/cli/cli_commands/model_utils.py

@@ -19,76 +19,101 @@ def _print_models_table(models, provider_name):
 
     # Get default model for this provider
     from janito.providers.registry import LLMProviderRegistry
+
     try:
         provider_class = LLMProviderRegistry.get(provider_name)
         default_model = getattr(provider_class, "DEFAULT_MODEL", None)
     except:
         default_model = None
-    
+
     for m in models:
         name = str(m.get("name", ""))
-        
+
         # Highlight default model with different color
         if name == default_model:
             name = f"[bold green]⭐ {name}[/bold green]"
-        
-        vendor = "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
-        
+
+        vendor = (
+            "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
+        )
+
         context = _format_context(m.get("context", ""))
         max_input = _format_k(m.get("max_input", ""))
         max_cot = _format_k(m.get("max_cot", ""))
         max_response = _format_k(m.get("max_response", ""))
-        
+
         # Determine thinking indicators
-        thinking_supported = m.get("thinking_supported") is True or m.get("thinking_supported") == "True"
+        thinking_supported = (
+            m.get("thinking_supported") is True or m.get("thinking_supported") == "True"
+        )
         cot_value = m.get("max_cot", "")
-        
+
         thinking_icon = "📖" if thinking_supported and m.get("thinking", False) else ""
         # Only show CoT value if it's a valid number and thinking is supported
         cot_display = ""
         if thinking_supported and cot_value and str(cot_value).lower() != "n/a":
             cot_display = _format_k(cot_value)
-        
+
         driver = _format_driver(m.get("driver", ""))
-        
-        table.add_row(name, vendor, context, max_input, cot_display, max_response, thinking_icon, driver)
+
+        table.add_row(
+            name,
+            vendor,
+            context,
+            max_input,
+            cot_display,
+            max_response,
+            thinking_icon,
+            driver,
+        )
 
     import sys
+
     if sys.stdout.isatty():
         shared_console.print(table)
     else:
         # ASCII-friendly fallback table when output is redirected
         print(f"Supported models for provider '{provider_name}'")
-        print("Model Name | Vendor | Context | Max Input | CoT | Max Response | Thinking | Driver")
-        
+        print(
+            "Model Name | Vendor | Context | Max Input | CoT | Max Response | Thinking | Driver"
+        )
+
         # Get default model for fallback
         from janito.providers.registry import LLMProviderRegistry
+
         try:
             provider_class = LLMProviderRegistry.get(provider_name)
             default_model = getattr(provider_class, "DEFAULT_MODEL", None)
         except:
             default_model = None
-            
+
         for m in models:
             name = str(m.get("name", ""))
             if name == default_model:
                 name = f"⭐ {name} (default)"
-            
-            vendor = "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
+
+            vendor = (
+                "Open" if m.get("open") is True or m.get("open") == "Open" else "Locked"
+            )
             context = _format_context(m.get("context", ""))
             max_input = _format_k(m.get("max_input", ""))
             max_cot = _format_k(m.get("max_cot", ""))
             max_response = _format_k(m.get("max_response", ""))
-            thinking_supported = m.get("thinking_supported") is True or m.get("thinking_supported") == "True"
+            thinking_supported = (
+                m.get("thinking_supported") is True
+                or m.get("thinking_supported") == "True"
+            )
             cot_value = m.get("max_cot", "")
-            
+
             thinking = "Y" if thinking_supported and m.get("thinking", False) else ""
             cot_display = ""
             if thinking_supported and cot_value and str(cot_value).lower() != "n/a":
                 cot_display = _format_k(cot_value)
-            
+
             driver = _format_driver(m.get("driver", ""))
-            print(f"{name} | {vendor} | {context} | {max_input} | {cot_display} | {max_response} | {thinking} | {driver}")
+            print(
+                f"{name} | {vendor} | {context} | {max_input} | {cot_display} | {max_response} | {thinking} | {driver}"
+            )
 
 
 def _format_k(val):

janito/cli/cli_commands/ping_providers.py

@@ -12,14 +12,14 @@ def handle_ping_providers(args):
     try:
         # Get all providers
         providers = list_providers()
-        
+
         # Create table for results
         table = Table(title="Provider Connectivity Test")
         table.add_column("Provider", style="cyan")
         table.add_column("Status", style="magenta")
         table.add_column("Time", style="green")
         table.add_column("Details", style="yellow")
-        
+
         # Test each provider
         for provider_name in providers:
             start_time = time.time()
@@ -27,7 +27,7 @@ def handle_ping_providers(args):
                 # Get provider class
                 provider_class = LLMProviderRegistry.get(provider_name)
                 provider = provider_class()
-                
+
                 # Test the provider (simplified - just check if we can instantiate and get models)
                 models = provider.get_models()
                 if models:
@@ -36,20 +36,20 @@ def handle_ping_providers(args):
                 else:
                     status = "⚠ No models"
                     details = "Provider reachable but no models returned"
-                
+
             except Exception as e:
                 status = "✗ Failed"
                 details = str(e)
-                
+
             end_time = time.time()
             elapsed = f"{(end_time - start_time)*1000:.0f}ms"
-            
+
             table.add_row(provider_name, status, elapsed, details)
-        
+
         # Print results
         shared_console.print(table)
-        
+
     except Exception as e:
         print(f"Error testing provider connectivity: {e}")
-    
-    return
+
+    return

janito/cli/cli_commands/set_api_key.py

@@ -13,13 +13,15 @@ def handle_set_api_key(args):
     if not provider:
         print("Error: --set-api-key requires -p/--provider to be specified.")
         return
-    
+
     # Validate provider name
     if provider not in LLMProviderRegistry.list_providers():
         valid_providers = LLMProviderRegistry.list_providers()
-        print(f"Error: Unknown provider '{provider}'. Valid providers are: {', '.join(valid_providers)}")
+        print(
+            f"Error: Unknown provider '{provider}'. Valid providers are: {', '.join(valid_providers)}"
+        )
         return
-        
+
     try:
         set_api_key(provider, api_key)
         auth_manager = LLMAuthManager()

janito/cli/cli_commands/show_config.py

@@ -42,24 +42,30 @@ def handle_show_config(args):
     console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
     if model is not None:
         console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
-    
+
     # Show all configuration values
     console.print("[bold green]Configuration values:[/bold green]")
     all_config = config.all()
     if all_config:
         for key, value in sorted(all_config.items()):
             # Hide sensitive values like API keys
-            if 'api_key' in key.lower() and value:
-                masked_value = value[:8] + '***' + value[-4:] if len(value) > 12 else '***'
+            if "api_key" in key.lower() and value:
+                masked_value = (
+                    value[:8] + "***" + value[-4:] if len(value) > 12 else "***"
+                )
                 console.print(f"  {key}: {masked_value!r}")
-            elif key == 'providers' and isinstance(value, dict):
+            elif key == "providers" and isinstance(value, dict):
                 # Handle nested provider configs with API keys
                 masked_providers = {}
                 for provider_name, provider_config in value.items():
                     masked_config = dict(provider_config)
-                    if 'api_key' in masked_config and masked_config['api_key']:
-                        api_key = masked_config['api_key']
-                        masked_config['api_key'] = api_key[:8] + '***' + api_key[-4:] if len(api_key) > 12 else '***'
+                    if "api_key" in masked_config and masked_config["api_key"]:
+                        api_key = masked_config["api_key"]
+                        masked_config["api_key"] = (
+                            api_key[:8] + "***" + api_key[-4:]
+                            if len(api_key) > 12
+                            else "***"
+                        )
                     masked_providers[provider_name] = masked_config
                 console.print(f"  {key}: {masked_providers!r}")
             else: