janito 2.3.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

janito/cli/chat_mode/session.py

@@ -3,6 +3,8 @@ Session management for Janito Chat CLI.
 Defines ChatSession and ChatShellState classes.
 """
 
+from __future__ import annotations
+
 import types
 from rich.console import Console
 from rich.rule import Rule
@@ -17,23 +19,22 @@ from janito.cli.chat_mode.bindings import KeyBindingsFactory
 from janito.cli.chat_mode.shell.commands import handle_command
 from janito.cli.chat_mode.shell.autocomplete import ShellCommandCompleter
 
+# Shared prompt/agent factory
+from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+
 
 class ChatShellState:
     def __init__(self, mem_history, conversation_history):
-        self.allow_execution = False  # Controls whether execution tools are enabled
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
-        self.termweb_port = None
-        self.termweb_pid = None
-        self.termweb_stdout_path = None
-        self.termweb_stderr_path = None
+        self._port = None
+        self._pid = None
+        self._stdout_path = None
+        self._stderr_path = None
         self.livereload_stderr_path = None
-        self.termweb_status = "starting"  # Tracks the current termweb status (updated by background thread/UI)
-        self.termweb_live_status = (
-            None  # 'online', 'offline', updated by background checker
-        )
-        self.termweb_live_checked_time = None  # datetime.datetime of last status check
+        self._status = "starting"  # Tracks the current  status (updated by background thread/UI)
+
         self.last_usage_info = {}
         self.last_elapsed = None
         self.main_agent = {}
@@ -53,25 +54,10 @@ class ChatSession:
         args=None,
         verbose_tools=False,
         verbose_agent=False,
-        exec_enabled=False
+        
+        allowed_permissions=None,
     ):
-        # Set allow_execution from exec_enabled or args
-        if args is not None and hasattr(args, "exec"):
-            allow_execution = bool(getattr(args, "exec", False))
-        else:
-            allow_execution = exec_enabled
-        from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
-
-        self._prompt_handler = GenericPromptHandler(
-            args=None,
-            conversation_history=(
-                None
-                if not hasattr(self, "shell_state")
-                else self.shell_state.conversation_history
-            ),
-            provider_instance=provider_instance,
-        )
-        self._prompt_handler.agent = None  # Will be set below if agent exists
+
         self.console = console
         self.user_input_history = UserInputHistory()
         self.input_dicts = self.user_input_history.load()
@@ -81,27 +67,54 @@ class ChatSession:
                 self.mem_history.append_string(item["input"])
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
-        from janito.agent.setup_agent import create_configured_agent
 
-        agent = create_configured_agent(
+        # --- Profile selection (interactive) ---------------------------------
+        profile = getattr(args, "profile", None) if args is not None else None
+        profile_system_prompt = None
+        if profile 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")
+                elif isinstance(result, str) and result.startswith("role:"):
+                    role = result[len("role:") :].strip()
+                    profile = "developer"
+                else:
+                    profile = (
+                        "developer" if result == "software developer" else result
+                    )
+            except ImportError:
+                profile = "helpful assistant"
+
+        # ---------------------------------------------------------------------
+        from janito.conversation_history import LLMConversationHistory
+
+        conversation_history = LLMConversationHistory()
+
+        # Build agent and core prompt handler via the shared helper
+        self.agent, self._prompt_handler = setup_agent_and_prompt_handler(
+            args=args,
             provider_instance=provider_instance,
             llm_driver_config=llm_driver_config,
             role=role,
             verbose_tools=verbose_tools,
             verbose_agent=verbose_agent,
-            exec_enabled=allow_execution
+            
+            allowed_permissions=allowed_permissions,
+            profile=profile,
+            profile_system_prompt=profile_system_prompt,
+            conversation_history=conversation_history,
         )
-        from janito.conversation_history import LLMConversationHistory
 
-        self.shell_state = ChatShellState(self.mem_history, LLMConversationHistory())
-        self.shell_state.agent = agent
-        self.shell_state.allow_execution = allow_execution
-        self.agent = agent
+        self.shell_state = ChatShellState(self.mem_history, conversation_history)
+        self.shell_state.agent = self.agent
         # Filter execution tools at startup
         try:
-            registry = getattr(__import__('janito.tools', fromlist=['get_local_tools_adapter']), 'get_local_tools_adapter')()
-            if hasattr(registry, 'set_execution_tools_enabled'):
-                registry.set_execution_tools_enabled(allow_execution)
+            # Permissions are now managed globally; registry filtering is automatic
+            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]")
         from janito.perf_singleton import performance_collector
@@ -114,76 +127,54 @@ class ChatSession:
             self.shell_state.conversation_history
         )
 
-        # TERMWEB logic migrated from runner
-        self.termweb_support = False
+        self._support = False
         if args and getattr(args, "web", False):
-            self.termweb_support = True
-            self.shell_state.termweb_support = self.termweb_support
-            from janito.cli.termweb_starter import termweb_start_and_watch
-            from janito.cli.config import get_termweb_port
+            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 termweb in background...[/yellow]")
-            self.termweb_lock = threading.Lock()
-            termweb_thread = termweb_start_and_watch(
-                self.shell_state, self.termweb_lock, get_termweb_port()
+            Console().print("[yellow]Starting  in background...[/yellow]")
+            self._lock = threading.Lock()
+            _thread = _start_and_watch(
+                self.shell_state, self._lock, get__port()
             )
             # Initial status is set to 'starting' by constructor; the watcher will update
-            self.termweb_thread = termweb_thread
+            self._thread = _thread
 
-            # Start a background timer to update live termweb status (for UI responsiveness)
+            # Start a background timer to update live  status (for UI responsiveness)
             import threading, datetime
 
-            def update_termweb_liveness():
-                while True:
-                    with self.termweb_lock:
-                        port = getattr(self.shell_state, "termweb_port", None)
-                        if port:
-                            try:
-                                # is_termweb_running is removed; inline health check here:
-                                try:
-                                    import http.client
-
-                                    conn = http.client.HTTPConnection(
-                                        "localhost", port, timeout=0.5
-                                    )
-                                    conn.request("GET", "/")
-                                    resp = conn.getresponse()
-                                    running = resp.status == 200
-                                except Exception:
-                                    running = False
-                                self.shell_state.termweb_live_status = (
-                                    "online" if running else "offline"
-                                )
-                            except Exception:
-                                self.shell_state.termweb_live_status = "offline"
-                            self.shell_state.termweb_live_checked_time = (
-                                datetime.datetime.now()
-                            )
-                        else:
-                            self.shell_state.termweb_live_status = None
-                            self.shell_state.termweb_live_checked_time = (
-                                datetime.datetime.now()
-                            )
-                    # sleep outside lock
-                    threading.Event().wait(1.0)
-
-            self._termweb_liveness_thread = threading.Thread(
-                target=update_termweb_liveness, daemon=True
-            )
-            self._termweb_liveness_thread.start()
-            # No queue or blocking checks; UI (and timer) will observe self.shell_state fields
+            # Health check and liveness thread removed as per refactor to eliminate localhost references.
 
         else:
-            self.shell_state.termweb_support = False
-            self.shell_state.termweb_status = "offline"
+            self.shell_state._support = False
+            self.shell_state._status = "offline"
 
     def run(self):
-        session = self._create_prompt_session()
+        self.console.clear()
+        from janito import __version__
         self.console.print(
-            "[bold green]Type /help for commands. Type /exit or press Ctrl+C to quit.[/bold green]"
+            f"[bold green]Janito Chat Mode v{__version__}[/bold green]"
         )
+        self.console.print("[green]/help for commands   /exit or Ctrl+C to quit[/green]")
+        import os
+        cwd = os.getcwd()
+        home = os.path.expanduser('~')
+        if cwd.startswith(home):
+            cwd_display = '~' + cwd[len(home):]
+        else:
+            cwd_display = cwd
+        self.console.print(f"[green]Working Dir:[/green] {cwd_display}")
+
+        # Inform user if no privileges are enabled
+        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]")
+
+        session = self._create_prompt_session()
         self._chat_loop(session)
 
     def _chat_loop(self, session):
@@ -199,40 +190,55 @@ class ChatSession:
                 continue
             if self._handle_exit_conditions(cmd_input):
                 break
-            if cmd_input.startswith("/"):
-                handle_command(cmd_input, shell_state=self.shell_state)
+            if self._handle_command_input(cmd_input):
                 continue
             self.user_input_history.append(cmd_input)
-            try:
-                final_event = (
-                    self._prompt_handler.agent.last_event
-                    if hasattr(self._prompt_handler.agent, "last_event")
+            self._process_prompt(cmd_input)
+
+    def _handle_command_input(self, cmd_input):
+        if cmd_input.startswith("/"):
+            handle_command(cmd_input, shell_state=self.shell_state)
+            return True
+        if cmd_input.startswith("!"):
+            # Pass everything after ! to the bang handler
+            handle_command(f"! {cmd_input[1:]}", shell_state=self.shell_state)
+            return True
+        return False
+
+    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")
+                else None
+            )
+            start_time = time.time()
+            self._prompt_handler.run_prompt(cmd_input)
+            end_time = time.time()
+            elapsed = end_time - start_time
+            self.msg_count += 1
+            # After prompt, print the stat line using the shared core function
+            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 exit reason if present in the final event
+            if final_event and hasattr(final_event, "metadata"):
+                exit_reason = (
+                    final_event.metadata.get("exit_reason")
+                    if hasattr(final_event, "metadata")
                     else None
                 )
-                self._prompt_handler.run_prompt(cmd_input)
-                self.msg_count += 1
-                # After prompt, print the stat line using the shared core function
-                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)
-                # Print exit reason if present in the final event
-                if final_event and hasattr(final_event, "metadata"):
-                    exit_reason = (
-                        final_event.metadata.get("exit_reason")
-                        if hasattr(final_event, "metadata")
-                        else None
+                if exit_reason:
+                    self.console.print(
+                        f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]"
                     )
-                    if exit_reason:
-                        self.console.print(
-                            f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]"
-                        )
-
-            except Exception as exc:
-                self.console.print(f"[red]Exception in agent: {exc}[/red]")
-                import traceback
 
-                self.console.print(traceback.format_exc())
+        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):
         return PromptSession(

janito/cli/chat_mode/session_profile_select.py

@@ -0,0 +1,80 @@
+"""
+Profile selection logic for Janito Chat CLI using questionary.
+"""
+import questionary
+from questionary import Style
+
+def select_profile():
+    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 {"profile": "assistant", "profile_system_prompt": None}
+    if answer == "using role...":
+        role_name = questionary.text("Enter the role name:").ask()
+        return f"role:{role_name}"
+    elif answer == "full custom system prompt...":
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.enums import EditingMode
+        from prompt_toolkit.formatted_text import HTML
+        from .prompt_style import chat_shell_style
+
+        mode = {"multiline": False}
+        bindings = KeyBindings()
+
+        @bindings.add("c-r")
+        def _(event):
+            pass
+
+        @bindings.add("f12")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Do It"
+            buf.validate_and_handle()
+
+        def get_toolbar():
+            if mode["multiline"]:
+                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>")
+
+        session = PromptSession(
+            multiline=False,
+            key_bindings=bindings,
+            editing_mode=EditingMode.EMACS,
+            bottom_toolbar=get_toolbar,
+            style=chat_shell_style,
+        )
+        prompt_icon = HTML("<inputline>📝 </inputline>")
+        while True:
+            response = session.prompt(prompt_icon)
+            if not mode["multiline"] and response.strip() == "/multi":
+                mode["multiline"] = True
+                session.multiline = True
+                continue
+            elif mode["multiline"] and response.strip() == "/single":
+                mode["multiline"] = False
+                session.multiline = False
+                continue
+            else:
+                sanitized = response.strip()
+                try:
+                    sanitized.encode("utf-8")
+                except UnicodeEncodeError:
+                    sanitized = sanitized.encode("utf-8", errors="replace").decode("utf-8")
+                return {"profile": None, "profile_system_prompt": sanitized}
+    return answer

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

@@ -1,21 +1,30 @@
 from .base import ShellCmdHandler
-from .edit import EditShellHandler
 from .history_view import ViewShellHandler
 from .lang import LangShellHandler
 from .livelogs import LivelogsShellHandler
-from .prompt import PromptShellHandler, RoleShellHandler, ProfileShellHandler
+from .prompt import PromptShellHandler, RoleShellHandler
 from .multi import MultiShellHandler
+from .model import ModelShellHandler
 from .role import RoleCommandShellHandler
 from .session import HistoryShellHandler
-from .termweb_log import TermwebLogTailShellHandler
 from .tools import ToolsShellHandler
 from .help import HelpShellHandler
 from janito.cli.console import shared_console
 
 COMMAND_HANDLERS = {
-    "/exec": __import__(
-        "janito.cli.chat_mode.shell.commands.exec", fromlist=["ExecShellHandler"]
-    ).ExecShellHandler,
+    # Bang handler for shell commands
+    "!": __import__(
+        "janito.cli.chat_mode.shell.commands.bang", fromlist=["BangShellHandler"]
+    ).BangShellHandler,
+    "/execute": __import__(
+        "janito.cli.chat_mode.shell.commands.execute", fromlist=["ExecuteShellHandler"]
+    ).ExecuteShellHandler,
+    "/read": __import__(
+        "janito.cli.chat_mode.shell.commands.read", fromlist=["ReadShellHandler"]
+    ).ReadShellHandler,
+    "/write": __import__(
+        "janito.cli.chat_mode.shell.commands.write", fromlist=["WriteShellHandler"]
+    ).WriteShellHandler,
     "/clear": __import__(
         "janito.cli.chat_mode.shell.commands.clear", fromlist=["ClearShellHandler"]
     ).ClearShellHandler,
@@ -23,16 +32,17 @@ COMMAND_HANDLERS = {
         "janito.cli.chat_mode.shell.commands.conversation_restart",
         fromlist=["RestartShellHandler"],
     ).RestartShellHandler,
-    "/edit": EditShellHandler,
+
     "/view": ViewShellHandler,
     "/lang": LangShellHandler,
     "/livelogs": LivelogsShellHandler,
     "/prompt": PromptShellHandler,
     "/role": RoleShellHandler,
-    "/profile": ProfileShellHandler,
+
     "/history": HistoryShellHandler,
-    "/termweb-logs": TermwebLogTailShellHandler,
+
     "/tools": ToolsShellHandler,
+    "/model": ModelShellHandler,
     "/multi": MultiShellHandler,
     "/help": HelpShellHandler,
 }

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,36 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+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."
+
+    def run(self):
+        if not self.shell_state:
+            shared_console.print("[red]Shell state unavailable.[/red]")
+            return
+        cmd = (self.after_cmd_line or "").strip()
+        if not cmd:
+            pd = PlatformDiscovery()
+            if pd.is_windows():
+                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]")
+                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)
+        else:
+            shared_console.print(f"[cyan]Running in Bash:[/cyan] {cmd}")
+            completed = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        output = completed.stdout
+        error = completed.stderr
+        if output:
+            shared_console.print(output)
+        if error:
+            shared_console.print(f"[red]{error}[/red]")

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

@@ -5,31 +5,8 @@ from janito.cli.console import shared_console
 
 
 def handle_restart(shell_state=None):
-    from janito.cli.chat_mode.shell.session.manager import (
-        load_last_conversation,
-        save_conversation,
-    )
-
     reset_session_id()
-    save_path = os.path.join(".janito", "last_conversation.json")
-
-    # --- Append end-of-conversation message to old history if it exists and is non-trivial ---
-    if os.path.exists(save_path):
-        try:
-            messages, prompts, usage = load_last_conversation(save_path)
-            if messages and (
-                len(messages) > 1
-                or (len(messages) == 1 and messages[0].get("role") != "system")
-            ):
-                messages.append(
-                    {"role": "system", "content": "[Session ended by user]"}
-                )
-                # Save to permanent chat history (let save_conversation pick session file)
-                save_conversation(messages, prompts, usage)
-        except Exception as e:
-            shared_console.print(
-                f"[bold red]Failed to update previous conversation history:[/bold red] {e}"
-            )
+    # Conversation history is no longer saved or loaded.
 
     # Clear the terminal screen
     shared_console.clear()
@@ -37,6 +14,12 @@ def handle_restart(shell_state=None):
     # Reset conversation history using the agent's method
     if hasattr(shell_state, "agent") and shell_state.agent:
         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()
+        if hasattr(shell_state.agent, "_refresh_system_prompt_from_template"):
+            shell_state.agent._refresh_system_prompt_from_template()
+        # No need to print the system prompt after restart
 
     # Reset tool use tracker
     try:
@@ -63,6 +46,30 @@ def handle_restart(shell_state=None):
             f"[bold yellow]Warning: Failed to reset PerformanceCollector token info:[/bold yellow] {e}"
         )
 
+    # Restore tool permissions to the CLI default on restart
+    try:
+        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))
+            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"):
+            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(
         "[bold green]Conversation history has been started (context reset).[/bold green]"
     )

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

@@ -0,0 +1,42 @@
+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 not self.shell_state:
+            shared_console.print("[red]Shell state unavailable.[/red]")
+            return
+        arg = (self.after_cmd_line or "").strip().lower()
+        if arg not in ("on", "off"):
+            shared_console.print("[yellow]Usage: /execute on|off[/yellow]")
+            return
+        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.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
+            )
+            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]")
+        # Refresh system prompt if agent is available
+        agent = getattr(self.shell_state, "agent", None)
+        if agent:
+            if hasattr(agent, "_refresh_system_prompt_from_template"):
+                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]")
+        else:
+            shared_console.print("[yellow]Execution tools DISABLED. Tools cannot run code or commands.[/yellow]")

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

@@ -1,16 +1,19 @@
 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"
 
     def run(self):
-        from . import (
-            COMMAND_HANDLERS,
-        )  # Import moved inside method to avoid circular import
+        from . import COMMAND_HANDLERS
+        from ._priv_check import user_has_any_privileges
 
         shared_console.print("[bold magenta]Available commands:[/bold magenta]")
         for cmd, handler_cls in sorted(COMMAND_HANDLERS.items()):
             help_text = getattr(handler_cls, "help_text", "")
             shared_console.print(f"[cyan]{cmd}[/cyan]: {help_text}")
+
+        # 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]")