janito 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

janito/cli/chat_mode/session.py

@@ -25,17 +25,20 @@ from janito.cli.prompt_setup import setup_agent_and_prompt_handler
 
 import time
 
+
 class ChatShellState:
     def __init__(self, mem_history, conversation_history):
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
-        self._port = None
+
         self._pid = None
         self._stdout_path = None
         self._stderr_path = None
-        self.livereload_stderr_path = None
-        self._status = "starting"  # Tracks the current  status (updated by background thread/UI)
+
+        self._status = (
+            "starting"  # Tracks the current  status (updated by background thread/UI)
+        )
 
         self.last_usage_info = {}
         self.last_elapsed = None
@@ -44,6 +47,8 @@ class ChatShellState:
         self.agent = None
         self.main_agent = None
         self.main_enabled = False
+        self.no_tools_mode = False
+
 
 class ChatSession:
     def __init__(
@@ -67,53 +72,88 @@ class ChatSession:
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
 
-        profile, role, profile_system_prompt = self._select_profile_and_role(args, role)
+        profile, role, profile_system_prompt, no_tools_mode = self._select_profile_and_role(args, role)
+        # Propagate no_tools_mode flag to downstream components via args
+        if args is not None and not hasattr(args, 'no_tools_mode'):
+            try:
+                setattr(args, 'no_tools_mode', no_tools_mode)
+            except Exception:
+                pass
         conversation_history = self._create_conversation_history()
         self.agent, self._prompt_handler = self._setup_agent_and_prompt_handler(
-            args, provider_instance, llm_driver_config, role, verbose_tools, verbose_agent, allowed_permissions, profile, profile_system_prompt, conversation_history
+            args,
+            provider_instance,
+            llm_driver_config,
+            role,
+            verbose_tools,
+            verbose_agent,
+            allowed_permissions,
+            profile,
+            profile_system_prompt,
+            conversation_history,
         )
         self.shell_state = ChatShellState(self.mem_history, conversation_history)
         self.shell_state.agent = self.agent
+        # Set no_tools_mode if present
+        self.shell_state.no_tools_mode = bool(no_tools_mode)
         self._filter_execution_tools()
         from janito.perf_singleton import performance_collector
+
         self.performance_collector = performance_collector
         self.key_bindings = KeyBindingsFactory.create()
         self._prompt_handler.agent = self.agent
-        self._prompt_handler.conversation_history = self.shell_state.conversation_history
+        self._prompt_handler.conversation_history = (
+            self.shell_state.conversation_history
+        )
         self._support = False
-        self._maybe_enable_web_support(args)
 
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
         profile_system_prompt = None
+        no_tools_mode = False
         if profile is None and role_arg is None:
             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"
+                    profile = "Developer with Python Tools"
                 else:
                     profile = (
-                        "developer" if result == "software developer" else result
+                        "Developer with Python Tools" if result == "Developer" else result
                     )
             except ImportError:
-                profile = "helpful assistant"
+                profile = "Raw Model Session (no tools, no context)"
         if role_arg is not None:
             role = role_arg
             if profile is None:
-                profile = "developer"
-        return profile, role, profile_system_prompt
+                profile = "Developer with Python Tools"
+        return profile, role, profile_system_prompt, no_tools_mode
 
     def _create_conversation_history(self):
         from janito.conversation_history import LLMConversationHistory
+
         return LLMConversationHistory()
 
-    def _setup_agent_and_prompt_handler(self, args, provider_instance, llm_driver_config, role, verbose_tools, verbose_agent, allowed_permissions, profile, profile_system_prompt, conversation_history):
+    def _setup_agent_and_prompt_handler(
+        self,
+        args,
+        provider_instance,
+        llm_driver_config,
+        role,
+        verbose_tools,
+        verbose_agent,
+        allowed_permissions,
+        profile,
+        profile_system_prompt,
+        conversation_history,
+    ):
         return setup_agent_and_prompt_handler(
             args=args,
             provider_instance=provider_instance,
@@ -129,23 +169,16 @@ class ChatSession:
 
     def _filter_execution_tools(self):
         try:
-            getattr(__import__('janito.tools', fromlist=['get_local_tools_adapter']), 'get_local_tools_adapter')()
+            getattr(
+                __import__("janito.tools", fromlist=["get_local_tools_adapter"]),
+                "get_local_tools_adapter",
+            )()
         except Exception as e:
-            self.console.print(f"[yellow]Warning: Could not filter execution tools at startup: {e}[/yellow]")
-
-    def _maybe_enable_web_support(self, args):
-        if args and getattr(args, "web", False):
-            self._support = True
-            self.shell_state._support = self._support
-            from janito.cli._starter import _start_and_watch
-            from janito.cli.config import get__port
-            import threading
-            from rich.console import Console
-            Console().print("[yellow]Starting  in background...[/yellow]")
-            self._lock = threading.Lock()
-            _thread = _start_and_watch(
-                self.shell_state, self._lock, get__port()
+            self.console.print(
+                f"[yellow]Warning: Could not filter execution tools at startup: {e}[/yellow]"
             )
+
+            _thread = _start_and_watch(self.shell_state, self._lock, get__port())
             self._thread = _thread
         else:
             self.shell_state._support = False
@@ -154,22 +187,29 @@ class ChatSession:
     def run(self):
         self.console.clear()
         from janito import __version__
+
+        self.console.print(f"[bold green]Janito Chat Mode v{__version__}[/bold green]")
         self.console.print(
-            f"[bold green]Janito Chat Mode v{__version__}[/bold green]"
+            "[green]/help for commands   /exit or Ctrl+C to quit[/green]"
         )
-        self.console.print("[green]/help for commands   /exit or Ctrl+C to quit[/green]")
         import os
+
         cwd = os.getcwd()
-        home = os.path.expanduser('~')
+        home = os.path.expanduser("~")
         if cwd.startswith(home):
-            cwd_display = '~' + cwd[len(home):]
+            cwd_display = "~" + cwd[len(home) :]
         else:
             cwd_display = cwd
         self.console.print(f"[green]Working Dir:[/green] {cwd_display}")
 
-        from janito.cli.chat_mode.shell.commands._priv_check import user_has_any_privileges
+        from janito.cli.chat_mode.shell.commands._priv_check import (
+            user_has_any_privileges,
+        )
+
         if not user_has_any_privileges():
-            self.console.print("[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]")
+            self.console.print(
+                "[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]"
+            )
 
         session = self._create_prompt_session()
         self._chat_loop(session)
@@ -204,6 +244,7 @@ class ChatSession:
     def _process_prompt(self, cmd_input):
         try:
             import time
+
             final_event = (
                 self._prompt_handler.agent.last_event
                 if hasattr(self._prompt_handler.agent, "last_event")
@@ -215,8 +256,11 @@ class ChatSession:
             elapsed = end_time - start_time
             self.msg_count += 1
             from janito.formatting_token import print_token_message_summary
+
             usage = self.performance_collector.get_last_request_usage()
-            print_token_message_summary(self.console, self.msg_count, usage, elapsed=elapsed)
+            print_token_message_summary(
+                self.console, self.msg_count, usage, elapsed=elapsed
+            )
             if final_event and hasattr(final_event, "metadata"):
                 exit_reason = (
                     final_event.metadata.get("exit_reason")
@@ -230,6 +274,7 @@ class ChatSession:
         except Exception as exc:
             self.console.print(f"[red]Exception in agent: {exc}[/red]")
             import traceback
+
             self.console.print(traceback.format_exc())
 
     def _create_prompt_session(self):

janito/cli/chat_mode/session_profile_select.py

@@ -16,20 +16,35 @@ from .prompt_style import chat_shell_style
 Profile selection logic for Janito Chat CLI using questionary.
 """
 
-def _handle_helpful_assistant():
-    return {"profile": "assistant", "profile_system_prompt": None}
+
+def _handle_raw_model_session_no_tools():
+    return {
+        "profile": "model_conversation_without_tools_or_context",
+        "profile_system_prompt": None,
+        "no_tools_mode": True,
+    }  # Raw Model Session (no tools, no context)
+
 
 def _handle_using_role():
     role_name = questionary.text("Enter the role name:").ask()
     return f"role:{role_name}"
 
+
 def _get_toolbar(mode):
     if mode["multiline"]:
-        return HTML("<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>")
+        return HTML(
+            "<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>"
+        )
     else:
-        return HTML("<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>")
+        return HTML(
+            "<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>"
+        )
+
 
 def _handle_custom_system_prompt():
+    print(
+        "\n[Custom System Prompt]\nPlease enter the message that will be used as the model system prompt. This will define how the AI behaves for this session.\nYou can use /multi for multiline mode, and /single to return to single-line mode.\n"
+    )
     mode = {"multiline": False}
     bindings = KeyBindings()
 
@@ -52,7 +67,13 @@ def _handle_custom_system_prompt():
     )
     prompt_icon = HTML("<inputline>📝 </inputline>")
     while True:
-        response = session.prompt(prompt_icon)
+        try:
+            response = session.prompt(prompt_icon)
+        except KeyboardInterrupt:
+            print("[Custom System Prompt] Exited by the user.")
+            import sys
+
+            sys.exit(0)
         if not mode["multiline"] and response.strip() == "/multi":
             mode["multiline"] = True
             session.multiline = True
@@ -88,63 +109,51 @@ def _load_user_profiles():
 def select_profile():
     user_profiles = _load_user_profiles()
     choices = [
-        "helpful assistant",
-        "developer",
-        "software developer",
-        "using role...",
-        "full custom system prompt..."
+        "Developer with Python Tools",
+        "Developer",
+        "Custom system prompt...",
+        "Raw Model Session (no tools, no context)",
     ]
     # Add user profiles to choices
     if user_profiles:
         choices.extend(user_profiles.keys())
 
-    custom_style = Style([
-        ("highlighted", "bg:#00aaff #ffffff"),  # background for item under cursor
-        ("question", "fg:#00aaff bold"),
-    ])
+    custom_style = Style(
+        [
+            ("highlighted", "bg:#00aaff #ffffff"),  # background for item under cursor
+            ("question", "fg:#00aaff bold"),
+        ]
+    )
     answer = questionary.select(
-        "Select a profile to use:",
-        choices=choices,
-        default=None,
-        style=custom_style
+        "Select a profile to use:", choices=choices, default=None, style=custom_style
     ).ask()
 
-    if answer == "helpful assistant":
-        return _handle_helpful_assistant()
-    if answer == "using role...":
-        return _handle_using_role()
-    elif answer == "full custom system prompt...":
+    if not answer:
+        import sys
+
+        sys.exit(0)
+
+    if answer == "Raw Model Session (no tools, no context)":
+        return _handle_raw_model_session_no_tools()
+    elif answer == "Custom system prompt...":
         return _handle_custom_system_prompt()
     elif answer in user_profiles:
         # Return the content of the user profile as a custom system prompt
         return {"profile": None, "profile_system_prompt": user_profiles[answer]}
-    elif answer == "software developer":
-        # Return the content of the built-in software developer profile prompt
-        with open("./janito/agent/templates/profiles/system_prompt_template_software_developer.txt.j2", "r", encoding="utf-8") as f:
-            prompt = f.read().strip()
-        return {"profile": "software developer", "profile_system_prompt": prompt}
-    return answer
-
-    choices = [
-        "helpful assistant",
-        "developer",
-        "using role...",
-        "full custom system prompt..."
-    ]
-    custom_style = Style([
-        ("highlighted", "bg:#00aaff #ffffff"),  # background for item under cursor
-        ("question", "fg:#00aaff bold"),
-    ])
-    answer = questionary.select(
-        "Select a profile to use:",
-        choices=choices,
-        default=None,
-        style=custom_style
-    ).ask()
-    if answer == "helpful assistant":
-        return _handle_helpful_assistant()
-    if answer == "using role...":
-        return _handle_using_role()
-    elif answer == "full custom system prompt...":
-        return _handle_custom_system_prompt()
+    elif answer == "Developer":
+        # Return the content of the built-in Developer profile prompt
+        from pathlib import Path
+        from jinja2 import Template
+        from janito.agent.setup_agent import _prepare_template_context
+
+        template_path = Path(
+            "./janito/agent/templates/profiles/system_prompt_template_Developer.txt.j2"
+        )
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_content = f.read()
+
+        template = Template(template_content)
+        context = _prepare_template_context("developer", "Developer", None)
+        prompt = template.render(**context)
+        return {"profile": "Developer", "profile_system_prompt": prompt}
     return answer

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

@@ -1,7 +1,7 @@
 from .base import ShellCmdHandler
 from .history_view import ViewShellHandler
 from .lang import LangShellHandler
-from .livelogs import LivelogsShellHandler
+
 from .prompt import PromptShellHandler, RoleShellHandler
 from .multi import MultiShellHandler
 from .model import ModelShellHandler
@@ -32,15 +32,11 @@ COMMAND_HANDLERS = {
         "janito.cli.chat_mode.shell.commands.conversation_restart",
         fromlist=["RestartShellHandler"],
     ).RestartShellHandler,
-
     "/view": ViewShellHandler,
     "/lang": LangShellHandler,
-    "/livelogs": LivelogsShellHandler,
     "/prompt": PromptShellHandler,
     "/role": RoleShellHandler,
-
     "/history": HistoryShellHandler,
-
     "/tools": ToolsShellHandler,
     "/model": ModelShellHandler,
     "/multi": MultiShellHandler,

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

@@ -1,5 +1,6 @@
 from janito.tools.permissions import get_global_allowed_permissions
 
+
 def user_has_any_privileges():
     perms = get_global_allowed_permissions()
     return perms.read or perms.write or perms.execute

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

@@ -4,6 +4,7 @@ from janito.platform_discovery import PlatformDiscovery
 import subprocess
 import sys
 
+
 class BangShellHandler(ShellCmdHandler):
     help_text = "!<cmd>: Run a shell command in the underlying shell (PowerShell or Bash). Usage: !ls -al or !Get-Process. Use ! with no command to launch an interactive shell."
 
@@ -15,16 +16,22 @@ class BangShellHandler(ShellCmdHandler):
         if not cmd:
             pd = PlatformDiscovery()
             if pd.is_windows():
-                shared_console.print("[yellow]Launching interactive PowerShell. Type 'exit' to return.[/yellow]")
+                shared_console.print(
+                    "[yellow]Launching interactive PowerShell. Type 'exit' to return.[/yellow]"
+                )
                 subprocess.run(["powershell.exe"], check=False)
             else:
-                shared_console.print("[yellow]Launching interactive Bash shell. Type 'exit' to return.[/yellow]")
+                shared_console.print(
+                    "[yellow]Launching interactive Bash shell. Type 'exit' to return.[/yellow]"
+                )
                 subprocess.run(["bash"], check=False)
             return
         pd = PlatformDiscovery()
         if pd.is_windows():
             shared_console.print(f"[cyan]Running in PowerShell:[/cyan] {cmd}")
-            completed = subprocess.run(["powershell.exe", "-Command", cmd], capture_output=True, text=True)
+            completed = subprocess.run(
+                ["powershell.exe", "-Command", cmd], capture_output=True, text=True
+            )
         else:
             shared_console.print(f"[cyan]Running in Bash:[/cyan] {cmd}")
             completed = subprocess.run(cmd, shell=True, capture_output=True, text=True)

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

@@ -16,7 +16,9 @@ def handle_restart(shell_state=None):
         shell_state.agent.reset_conversation_history()
         # Reset system prompt to original template context if available
         if hasattr(shell_state.agent, "_original_template_vars"):
-            shell_state.agent._template_vars = shell_state.agent._original_template_vars.copy()
+            shell_state.agent._template_vars = (
+                shell_state.agent._original_template_vars.copy()
+            )
         shell_state.agent.refresh_system_prompt_from_template()
         # No need to print the system prompt after restart
 
@@ -47,27 +49,42 @@ def handle_restart(shell_state=None):
 
     # Restore tool permissions to the CLI default on restart
     try:
-        from janito.tools.permissions import set_global_allowed_permissions, get_default_allowed_permissions
+        from janito.tools.permissions import (
+            set_global_allowed_permissions,
+            get_default_allowed_permissions,
+        )
         import janito.tools
+
         default_perms = get_default_allowed_permissions()
         if default_perms is not None:
             set_global_allowed_permissions(default_perms)
             janito.tools.local_tools_adapter.set_allowed_permissions(default_perms)
             msg = None
-        
+
         else:
             from janito.tools.tool_base import ToolPermissions
-            set_global_allowed_permissions(ToolPermissions(read=False, write=False, execute=False))
-            janito.tools.local_tools_adapter.set_allowed_permissions(ToolPermissions(read=False, write=False, execute=False))
+
+            set_global_allowed_permissions(
+                ToolPermissions(read=False, write=False, execute=False)
+            )
+            janito.tools.local_tools_adapter.set_allowed_permissions(
+                ToolPermissions(read=False, write=False, execute=False)
+            )
             msg = "[green]All tool permissions have been set to OFF (read, write, execute = False).[/green]"
         # Refresh system prompt to reflect new permissions
-        if hasattr(shell_state, "agent") and shell_state.agent and hasattr(shell_state.agent, "refresh_system_prompt_from_template"):
+        if (
+            hasattr(shell_state, "agent")
+            and shell_state.agent
+            and hasattr(shell_state.agent, "refresh_system_prompt_from_template")
+        ):
             shell_state.agent.refresh_system_prompt_from_template()
         if msg:
             shared_console.print(msg)
 
     except Exception as e:
-        shared_console.print(f"[yellow]Warning: Failed to restore tool permissions: {e}[/yellow]")
+        shared_console.print(
+            f"[yellow]Warning: Failed to restore tool permissions: {e}[/yellow]"
+        )
 
     shared_console.print(
         "[bold green]Conversation history has been started (context reset).[/bold green]"

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

@@ -1,10 +1,14 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class ExecuteShellHandler(ShellCmdHandler):
     help_text = "/execute on|off: Enable or disable code and command execution tools. Usage: /execute on or /execute 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]")
+            return
         if not self.shell_state:
             shared_console.print("[red]Shell state unavailable.[/red]")
             return
@@ -15,27 +19,38 @@ class ExecuteShellHandler(ShellCmdHandler):
         enable = arg == "on"
         # Dynamically enable/disable execution tools in the registry
         try:
-            from janito.tools.permissions import set_global_allowed_permissions, get_global_allowed_permissions
+            from janito.tools.permissions import (
+                set_global_allowed_permissions,
+                get_global_allowed_permissions,
+            )
             from janito.tools.tool_base import ToolPermissions
+
             current_perms = get_global_allowed_permissions()
             new_perms = ToolPermissions(
-                read=getattr(current_perms, 'read', False),
-                write=getattr(current_perms, 'write', False),
-                execute=enable
+                read=getattr(current_perms, "read", False),
+                write=getattr(current_perms, "write", False),
+                execute=enable,
             )
             set_global_allowed_permissions(new_perms)
             # Also update the singleton tools registry permissions
             import janito.tools
+
             janito.tools.local_tools_adapter.set_allowed_permissions(new_perms)
 
         except Exception as e:
-            shared_console.print(f"[yellow]Warning: Could not update execution tools dynamically: {e}[/yellow]")
+            shared_console.print(
+                f"[yellow]Warning: Could not update execution tools dynamically: {e}[/yellow]"
+            )
         # Refresh system prompt if agent is available
         agent = getattr(self.shell_state, "agent", None)
         if agent:
             agent.refresh_system_prompt_from_template()
             # No need to print the system prompt after permission change
         if enable:
-            shared_console.print("[green]Execution tools ENABLED. Tools can now execute code and commands.[/green]")
+            shared_console.print(
+                "[green]Execution tools ENABLED. Tools can now execute code and commands.[/green]"
+            )
         else:
-            shared_console.print("[yellow]Execution tools DISABLED. Tools cannot run code or commands.[/yellow]")
+            shared_console.print(
+                "[yellow]Execution tools DISABLED. Tools cannot run code or commands.[/yellow]"
+            )

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

@@ -2,6 +2,7 @@ from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 from janito.cli.console import shared_console
 import os
 
+
 class HelpShellHandler(ShellCmdHandler):
     help_text = "Show this help message"
 
@@ -16,4 +17,6 @@ class HelpShellHandler(ShellCmdHandler):
 
         # After help, print privilege info if user has no privileges
         if not user_has_any_privileges():
-            shared_console.print("[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]")
+            shared_console.print(
+                "[yellow]Note: You currently have no privileges enabled. If you need to interact with files or the system, enable permissions using /read on, /write on, or /execute on.[/yellow]"
+            )

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

@@ -4,6 +4,7 @@ from janito.cli.config import config
 
 from janito.cli.cli_commands.show_config import resolve_effective_model
 
+
 class ModelShellHandler(ShellCmdHandler):
     help_text = "Change or show the current LLM model (usage: /model [MODEL_NAME])"
 
@@ -14,15 +15,22 @@ class ModelShellHandler(ShellCmdHandler):
             provider = config.get("provider")
             effective_model = resolve_effective_model(provider) if provider else None
             if effective_model:
-                shared_console.print(f"[bold green]Current effective model:[/bold green] {effective_model}")
+                shared_console.print(
+                    f"[bold green]Current effective model:[/bold green] {effective_model}"
+                )
             else:
-                shared_console.print("[bold yellow]No model is currently set.[/bold yellow]")
+                shared_console.print(
+                    "[bold yellow]No model is currently set.[/bold yellow]"
+                )
             return
         # Set new model (global override)
         config.runtime_set("model", model_name)
         # Update agent's model in shell_state if possible
         agent = getattr(self.shell_state, "agent", None)
-        if agent is not None and hasattr(agent, "reset_driver_config_to_model_defaults"):
+        if agent is not None and hasattr(
+            agent, "reset_driver_config_to_model_defaults"
+        ):
             agent.reset_driver_config_to_model_defaults(model_name)
-        shared_console.print(f"[bold green]Model and config reset to defaults for:[/bold green] {model_name}")
-
+        shared_console.print(
+            f"[bold green]Model and config reset to defaults for:[/bold green] {model_name}"
+        )

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

@@ -0,0 +1,21 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+class PrivilegesShellHandler(ShellCmdHandler):
+    help_text = "Show current tool privileges or availability."
+
+    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]")
+            return
+        try:
+            from janito.tools.permissions import get_global_allowed_permissions
+            perms = get_global_allowed_permissions()
+            lines = ["[bold]Current tool privileges:[/bold]"]
+            lines.append(f"Read:     {'✅' if perms.read else '❌'}")
+            lines.append(f"Write:    {'✅' if perms.write else '❌'}")
+            lines.append(f"Execute:  {'✅' if perms.execute else '❌'}")
+            shared_console.print("\n".join(lines))
+        except Exception as e:
+            shared_console.print(f"[red]Error fetching privileges: {e}[/red]")

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

@@ -45,5 +45,3 @@ class RoleShellHandler(ShellCmdHandler):
         shared_console.print(
             f"[bold green]System role updated to:[/bold green] {new_role}"
         )
-
-