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

janito/cli/chat_mode/session.py

@@ -130,25 +130,39 @@ class ChatSession:
             profile = "Market Analyst"
 
         if profile is None and role_arg is None and not python_profile and not market_profile:
-            try:
-                from janito.cli.chat_mode.session_profile_select import select_profile
-
-                result = select_profile()
-                if isinstance(result, dict):
-                    profile = result.get("profile")
-                    profile_system_prompt = result.get("profile_system_prompt")
-                    no_tools_mode = result.get("no_tools_mode", False)
-                elif isinstance(result, str) and result.startswith("role:"):
-                    role = result[len("role:") :].strip()
-                    profile = "Developer with Python Tools"
-                else:
-                    profile = (
-                        "Developer with Python Tools"
-                        if result == "Developer"
-                        else result
-                    )
-            except ImportError:
-                profile = "Raw Model Session (no tools, no context)"
+            # Skip interactive profile selection for list commands
+            from janito.cli.core.getters import GETTER_KEYS
+            
+            # Check if any getter command is active - these don't need interactive mode
+            skip_profile_selection = False
+            if args is not None:
+                for key in GETTER_KEYS:
+                    if getattr(args, key, False):
+                        skip_profile_selection = True
+                        break
+            
+            if skip_profile_selection:
+                profile = "Developer with Python Tools"  # Default for non-interactive commands
+            else:
+                try:
+                    from janito.cli.chat_mode.session_profile_select import select_profile
+
+                    result = select_profile()
+                    if isinstance(result, dict):
+                        profile = result.get("profile")
+                        profile_system_prompt = result.get("profile_system_prompt")
+                        no_tools_mode = result.get("no_tools_mode", False)
+                    elif isinstance(result, str) and result.startswith("role:"):
+                        role = result[len("role:") :].strip()
+                        profile = "Developer with Python Tools"
+                    else:
+                        profile = (
+                            "Developer with Python Tools"
+                            if result == "Developer"
+                            else result
+                        )
+                except ImportError:
+                    profile = "Raw Model Session (no tools, no context)"
         if role_arg is not None:
             role = role_arg
             if profile is None:
@@ -209,9 +223,7 @@ class ChatSession:
 
         self.console.print(f"[bold green]Janito Chat Mode v{__version__}[/bold green]")
         self.console.print(f"[dim]Profile: {self.profile}[/dim]")
-        self.console.print(
-            "[green]/help for commands   /exit or Ctrl+C to quit[/green]"
-        )
+
         import os
 
         cwd = os.getcwd()
@@ -226,7 +238,7 @@ class ChatSession:
 
         priv_status = get_privilege_status_message()
         self.console.print(
-            f"[green]Working Dir:[/green] {cwd_display}  |  {priv_status}"
+            f"[green]Working Dir:[/green] [cyan]{cwd_display}[/cyan]  |  {priv_status}"
         )
 
         if self.multi_line_mode:
@@ -282,6 +294,8 @@ class ChatSession:
 
     def _process_prompt(self, cmd_input):
         try:
+            # Clear screen before processing new prompt
+            self.console.clear()
             import time
 
             final_event = (

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

@@ -1,6 +1,7 @@
 from .base import ShellCmdHandler
 from .history_view import ViewShellHandler
 from .lang import LangShellHandler
+from .provider import ProviderCmdHandler
 
 from .prompt import PromptShellHandler, RoleShellHandler
 from .multi import MultiShellHandler
@@ -43,6 +44,7 @@ COMMAND_HANDLERS = {
     "/multi": MultiShellHandler,
     "/help": HelpShellHandler,
     "/security": SecurityCommand,
+    "/provider": ProviderCmdHandler,
 }
 
 

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

@@ -7,7 +7,12 @@ class HelpShellHandler(ShellCmdHandler):
     help_text = "Show this help message"
 
     def run(self):
-        from . import COMMAND_HANDLERS
+        # Ensure /provider command is registered before showing help
+        from janito.cli.chat_mode.shell.commands import COMMAND_HANDLERS
+        if "/provider" not in COMMAND_HANDLERS:
+            from janito.cli.chat_mode.shell.commands.provider import ProviderCmdHandler
+            COMMAND_HANDLERS["/provider"] = ProviderCmdHandler
+
         from ._priv_check import user_has_any_privileges
 
         shared_console.print("[bold magenta]Available commands:[/bold magenta]")

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

@@ -0,0 +1,25 @@
+from janito.cli.core.getters import get_current_provider
+from janito.cli.core.setters import set_provider
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console as console
+
+class ProviderCmdHandler(ShellCmdHandler):
+    """Handler for the /provider command to view or change the current provider."""
+    
+    help_text = "Manage the current LLM provider. Usage: /provider [provider_name]"
+    
+    def run(self):
+        """Execute the provider command."""
+        if not self.after_cmd_line.strip():
+            # No argument provided, show current provider
+            current = get_current_provider()
+            console.print(f"[bold]Current provider:[/bold] {current}")
+            return
+            
+        # Argument provided, attempt to change provider
+        new_provider = self.after_cmd_line.strip()
+        try:
+            set_provider(new_provider)
+            console.print(f"[bold green]Provider changed to:[/bold green] {new_provider}")
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")

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,64 @@
+"""
+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_plugins.py

@@ -7,6 +7,7 @@ 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:
@@ -15,10 +16,23 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
     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:")
@@ -65,8 +79,10 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
             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}")

janito/cli/cli_commands/show_config.py

@@ -42,6 +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 '***'
+                console.print(f"  {key}: {masked_value!r}")
+            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 '***'
+                    masked_providers[provider_name] = masked_config
+                console.print(f"  {key}: {masked_providers!r}")
+            else:
+                console.print(f"  {key}: {value!r}")
+    else:
+        console.print("  (no configuration values set)")
 
     # Show disabled tools
     from janito.tools.disabled_tools import load_disabled_tools_from_config

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,10 @@ 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 +61,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/runner.py

@@ -174,7 +174,21 @@ def handle_runner(
             "Active LLMDriverConfig (after provider)", llm_driver_config, style="green"
         )
         print_verbose_info("Agent role", agent_role, style="green")
-    if mode == "single_shot":
+    
+    # Skip chat mode for list commands - handle them directly
+    from janito.cli.core.getters import GETTER_KEYS
+    skip_chat_mode = False
+    if args is not None:
+        for key in GETTER_KEYS:
+            if getattr(args, key, False):
+                skip_chat_mode = True
+                break
+    
+    if skip_chat_mode:
+        # Handle list commands directly without prompt
+        from janito.cli.core.getters import handle_getter
+        handle_getter(args)
+    elif mode == "single_shot":
         from janito.cli.single_shot_mode.handler import (
             PromptHandler as SingleShotPromptHandler,
         )

janito/cli/core/setters.py

@@ -101,17 +101,29 @@ def _handle_set_base_url(value):
     return True
 
 
-def _handle_set_config_provider(value):
+def set_provider(value):
+    """Set the current provider.
+    
+    Args:
+        value (str): The provider name to set
+        
+    Raises:
+        ValueError: If the provider is not supported
+    """
     try:
         supported = ProviderRegistry().get_provider(value)
     except Exception:
-        print(
-            f"Error: Provider '{value}' is not supported. Run '--list-providers' to see the supported list."
-        )
-        return True
+        raise ValueError(f"Provider '{value}' is not supported. Run '--list-providers' to see the supported list.")
     from janito.provider_config import set_config_provider
-
     set_config_provider(value)
+    
+
+def _handle_set_config_provider(value):
+    try:
+        set_provider(value)
+    except ValueError as e:
+        print(f"Error: {str(e)}")
+        return True
     print(f"Provider set to '{value}'.")
     return True
 

janito/cli/main_cli.py

@@ -293,7 +293,8 @@ class JanitoCLI:
         self.parser = argparse.ArgumentParser(
             description="Janito CLI - A tool for running LLM-powered workflows from the command line."
             "\n\nExample usage: janito -p moonshotai -m kimi-k1-8k 'Your prompt here'\n\n"
-            "Use -m or --model to set the model for the session."
+            "Use -m or --model to set the model for the session.",
+
         )
         self._define_args()
         self.args = self.parser.parse_args()
@@ -404,15 +405,27 @@ class JanitoCLI:
             or self.args.list_drivers
             or self.args.list_plugins
             or self.args.list_plugins_available
+            or self.args.list_resources
             or self.args.ping
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
+        # Handle /rwx prefix for enabling all permissions
+        if self.args.user_prompt and self.args.user_prompt[0] == '/rwx':
+            self.args.read = True
+            self.args.write = True
+            self.args.exec = True
+            # Remove the /rwx prefix from the prompt
+            self.args.user_prompt = self.args.user_prompt[1:]
+        elif self.args.user_prompt and self.args.user_prompt[0].startswith('/'):
+            # Skip LLM processing for other commands that start with /
+            return
+            
         # If running in single shot mode and --profile is not provided, default to 'developer' profile
-        if get_prompt_mode(self.args) == "single_shot" and not getattr(
-            self.args, "profile", None
-        ):
+        # Skip profile selection for list commands that don't need it
+        if (get_prompt_mode(self.args) == "single_shot" and 
+            not getattr(self.args, "profile", None)):
             self.args.profile = "developer"
         provider = self._get_provider_or_default()
         if provider is None:
@@ -441,8 +454,6 @@ class JanitoCLI:
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
             )
-        elif run_mode == RunMode.GET:
-            handle_getter(self.args)
 
     def _run_set_mode(self):
         if handle_api_key_set(self.args):

janito/plugins/builtin.py

@@ -0,0 +1,84 @@
+"""
+Builtin plugin system for janito-packaged plugins.
+
+This module provides the infrastructure for plugins that are bundled
+with janito and available by default without requiring external installation.
+"""
+
+import importlib
+from typing import Dict, List, Optional, Type
+from janito.plugins.base import Plugin
+
+
+class BuiltinPluginRegistry:
+    """Registry for builtin plugins that come packaged with janito."""
+    
+    _plugins: Dict[str, Type[Plugin]] = {}
+    
+    @classmethod
+    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
+        """Register a builtin plugin."""
+        cls._plugins[name] = plugin_class
+    
+    @classmethod
+    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
+        """Get the plugin class for a builtin plugin."""
+        return cls._plugins.get(name)
+    
+    @classmethod
+    def list_builtin_plugins(cls) -> List[str]:
+        """List all registered builtin plugins."""
+        return list(cls._plugins.keys())
+    
+    @classmethod
+    def is_builtin(cls, name: str) -> bool:
+        """Check if a plugin is builtin."""
+        return name in cls._plugins
+
+
+def register_builtin_plugin(name: str):
+    """Decorator to register a plugin as builtin."""
+    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
+        BuiltinPluginRegistry.register(name, plugin_class)
+        return plugin_class
+    return decorator
+
+
+def load_builtin_plugin(name: str) -> Optional[Plugin]:
+    """Load a builtin plugin by name."""
+    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
+    if plugin_class:
+        return plugin_class()
+    return None
+
+
+# Auto-register janito-coder plugins as builtin
+try:
+    from janito_coder.plugins import (
+        GitAnalyzerPlugin,
+        CodeNavigatorPlugin,
+        DependencyAnalyzerPlugin,
+        CodeFormatterPlugin,
+        TestRunnerPlugin,
+        LinterPlugin,
+        DebuggerPlugin,
+        PerformanceProfilerPlugin,
+        SecurityScannerPlugin,
+        DocumentationGeneratorPlugin,
+    )
+    
+    # Register all janito-coder plugins as builtin
+    BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
+    BuiltinPluginRegistry.register("dependency_analyzer", DependencyAnalyzerPlugin)
+    BuiltinPluginRegistry.register("code_formatter", CodeFormatterPlugin)
+    BuiltinPluginRegistry.register("test_runner", TestRunnerPlugin)
+    BuiltinPluginRegistry.register("linter", LinterPlugin)
+    BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
+    BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
+    BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
+    BuiltinPluginRegistry.register("documentation_generator", DocumentationGeneratorPlugin)
+    
+except ImportError:
+    # janito-coder not available, skip registration
+    pass