janito 2.27.0__py3-none-any.whl → 2.28.0__py3-none-any.whl

janito/cli/chat_mode/toolbar.py

@@ -1,3 +1,4 @@
+import os
 from prompt_toolkit.formatted_text import HTML
 from janito.performance_collector import PerformanceCollector
 from janito.cli.config import config
@@ -17,7 +18,20 @@ def format_tokens(n, tag=None):
 
 
 def assemble_first_line(provider_name, model_name, role, agent=None):
-    return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Role: <role>{role}</role>"
+    cwd = os.getcwd()
+    home = os.path.expanduser("~")
+
+    # Convert to relative path if under home directory
+    if cwd.startswith(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>"
 
 
 def assemble_bindings_line(width, permissions=None):

janito/cli/cli_commands/enable_disable_plugin.py

@@ -0,0 +1,87 @@
+"""
+CLI command to enable/disable plugins by modifying plugins.json configuration.
+"""
+
+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.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"] = {}
+
+    # Set the plugin to enabled (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'"
+        )
+    else:
+        print(f"Error: Failed to enable plugin '{args.plugin_name}'")
+
+
+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"]
+    ):
+        # Remove the plugin entry or set it to False
+        if args.remove:
+            del config["plugins"]["load"][args.plugin_name]
+            action = "removed"
+        else:
+            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'"
+            )
+        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"
+        )
+
+
+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")
+
+
+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",
+    )

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

@@ -7,49 +7,65 @@ from typing import List, Dict, Any
 from janito.plugins.discovery import list_available_plugins, discover_plugins
 import os
 from janito.plugins.manager import PluginManager
+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()
-        if available:
+        builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
+
+        if available or builtin_plugins:
             print("Available plugins:")
-            for plugin in available:
-                print(f"  - {plugin}")
+
+            # 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:
+                print("  External plugins:")
+                for plugin in other_plugins:
+                    print(f"    - {plugin}")
         else:
             print("No plugins found in search paths")
             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:
@@ -60,18 +76,18 @@ 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:
                 metadata = manager.get_plugin_metadata(plugin_name)
+                is_builtin = BuiltinPluginRegistry.is_builtin(plugin_name)
                 if metadata:
-                    print(f"  - {metadata.name} v{metadata.version}")
+                    builtin_tag = " [BUILTIN]" if is_builtin else ""
+                    print(f"  - {metadata.name} v{metadata.version}{builtin_tag}")
                     print(f"    {metadata.description}")
                     if metadata.author:
                         print(f"    Author: {metadata.author}")
                     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:

janito/cli/cli_commands/show_system_prompt.py

@@ -64,6 +64,7 @@ def _load_template(profile, templates_dir):
             # Also check user profiles directory
             from pathlib import Path
             import os
+
             user_profiles_dir = Path(os.path.expanduser("~/.janito/profiles"))
             user_template_path = user_profiles_dir / template_filename
             if user_template_path.exists():
@@ -116,11 +117,11 @@ def handle_show_system_prompt(args):
         Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
     )
     profile = getattr(args, "profile", None)
-    
+
     # Handle --market flag mapping to Market Analyst profile
     if profile is None and getattr(args, "market", False):
         profile = "Market Analyst"
-    
+
     if not profile:
         print(
             "[janito] No profile specified. The main agent runs without a system prompt template.\n"
@@ -134,11 +135,17 @@ def handle_show_system_prompt(args):
     if not template_content:
         # Try to load directly from package resources as fallback
         try:
-            template_content = resources.files("janito.agent.templates.profiles").joinpath(
-                f"system_prompt_template_{profile.lower().replace(' ', '_')}.txt.j2"
-            ).read_text(encoding="utf-8")
+            template_content = (
+                resources.files("janito.agent.templates.profiles")
+                .joinpath(
+                    f"system_prompt_template_{profile.lower().replace(' ', '_')}.txt.j2"
+                )
+                .read_text(encoding="utf-8")
+            )
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            print(f"[janito] Could not find profile '{profile}'. This may be a configuration issue.")
+            print(
+                f"[janito] Could not find profile '{profile}'. This may be a configuration issue."
+            )
             return
 
     template = Template(template_content)

janito/cli/core/getters.py

@@ -13,6 +13,7 @@ from janito.cli.cli_commands.list_providers_region import handle_list_providers_
 from janito.cli.cli_commands.list_plugins import handle_list_plugins
 from functools import partial
 from janito.provider_registry import ProviderRegistry
+from janito.config import config as global_config
 
 GETTER_KEYS = [
     "show_config",
@@ -30,6 +31,11 @@ GETTER_KEYS = [
 ]
 
 
+def get_current_provider():
+    """Get the current provider from the global config."""
+    return global_config.get("provider", "none")
+
+
 def handle_getter(args, config_mgr=None):
     provider_instance = None
     if getattr(args, "list_models", False):
@@ -56,6 +62,7 @@ def handle_getter(args, config_mgr=None):
         "region_info": partial(handle_region_info, args),
         "list_providers_region": partial(handle_list_providers_region, args),
         "list_plugins": partial(handle_list_plugins, args),
+        "list_plugins_available": partial(handle_list_plugins, args),
         "list_resources": partial(handle_list_plugins, args),
     }
     for arg in GETTER_KEYS:

janito/cli/core/model_guesser.py

@@ -8,44 +8,47 @@ from janito.providers.registry import LLMProviderRegistry
 def guess_provider_from_model(model_name: str) -> str:
     """
     Guess the provider based on the model name.
-    
+
     Args:
         model_name: The name of the model to guess the provider for
-        
+
     Returns:
         The provider name if a match is found, None otherwise
     """
     if not model_name:
         return None
-    
+
     model_name = model_name.lower()
-    
+
     # Check each provider's models
     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'):
+            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 moonshotai
-            if provider_name == "moonshotai":
+
+            # Handle special cases like moonshot
+            if provider_name == "moonshot":
                 try:
-                    from janito.providers.moonshotai.model_info import MOONSHOTAI_MODEL_SPECS
-                    for spec_model_name in MOONSHOTAI_MODEL_SPECS.keys():
+                    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 "moonshotai"
+                            return "moonshot"
                 except ImportError:
                     pass
-                    
+
         except Exception:
             # Skip providers that have issues accessing model specs
             continue
-    
-    return None
+
+    return None