janito 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

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",
-        "plain_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 == "plain_software_developer":
-        # Return the content of the built-in plain_software_developer profile prompt
-        with open("./janito/agent/templates/profiles/system_prompt_template_plain_software_developer.txt.j2", "r", encoding="utf-8") as f:
-            prompt = f.read().strip()
-        return {"profile": "plain_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/_priv_status.py

@@ -0,0 +1,13 @@
+from janito.tools.permissions import get_global_allowed_permissions
+
+
+def get_privilege_status_message():
+    perms = get_global_allowed_permissions()
+    if perms.read and perms.write:
+        return "[cyan]Read-Write tools enabled[/cyan]"
+    elif perms.read:
+        return "[cyan]Read-Only tools enabled[/cyan]"
+    elif perms.write:
+        return "[cyan]Write-Only tools enabled[/cyan]"
+    else:
+        return "[yellow]No tool permissions enabled[/yellow]"

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}"
         )
-
-

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

@@ -1,10 +1,14 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class ReadShellHandler(ShellCmdHandler):
     help_text = "/read on|off: Enable or disable read permissions for tools. Usage: /read on or /read 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
@@ -14,23 +18,36 @@ class ReadShellHandler(ShellCmdHandler):
             return
         enable = arg == "on"
         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 = get_global_allowed_permissions()
-            new_perms = ToolPermissions(read=enable, write=current.write, execute=current.execute)
+            new_perms = ToolPermissions(
+                read=enable, write=current.write, execute=current.execute
+            )
             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 read permissions dynamically: {e}[/yellow]")
+            shared_console.print(
+                f"[yellow]Warning: Could not update read permissions 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]Read permissions ENABLED. Tools can now read files and data.[/green]")
+            shared_console.print(
+                "[green]Read permissions ENABLED. Tools can now read files and data.[/green]"
+            )
         else:
-            shared_console.print("[yellow]Read permissions DISABLED. Tools cannot read files/data.[/yellow]")
+            shared_console.print(
+                "[yellow]Read permissions DISABLED. Tools cannot read files/data.[/yellow]"
+            )

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

@@ -1,6 +1,7 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class ToolsShellHandler(ShellCmdHandler):
     help_text = "List available tools"
 
@@ -27,7 +28,7 @@ class ToolsShellHandler(ShellCmdHandler):
         perm_groups = {}
         for tool in tools:
             inst = tool_instances.get(tool, None)
-            perms = getattr(inst, 'permissions', None)
+            perms = getattr(inst, "permissions", None)
             if not perms:
                 group = "unknown"
             else:
@@ -37,6 +38,7 @@ class ToolsShellHandler(ShellCmdHandler):
 
     def _print_tools_table(self, perm_groups):
         from rich.table import Table
+
         table = Table(title="Tools by Permission Class")
         table.add_column("Permission Type", style="cyan", no_wrap=True)
         table.add_column("Tools", style="magenta")
@@ -47,27 +49,36 @@ class ToolsShellHandler(ShellCmdHandler):
     def _find_exec_tools(self, registry):
         exec_tools = []
         for tool_instance in registry.get_tools():
-            perms = getattr(tool_instance, 'permissions', None)
+            perms = getattr(tool_instance, "permissions", None)
             if perms and perms.execute:
                 exec_tools.append(tool_instance.tool_name)
         return exec_tools
 
     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:
             import janito.tools  # Ensure all tools are registered
             from janito.tools.permissions import get_global_allowed_permissions
+
             registry = janito.tools.get_local_tools_adapter()
             tools = registry.list_tools()
             shared_console.print("Registered tools:")
             tool_instances = {t.tool_name: t for t in registry.get_tools()}
             if not tools:
-                shared_console.print("No tools are enabled under the current permission settings.")
+                shared_console.print(
+                    "No tools are enabled under the current permission settings."
+                )
                 return
             perm_groups = self._group_tools_by_permission(tools, tool_instances)
             self._print_tools_table(perm_groups)
             exec_tools = self._find_exec_tools(registry)
             perms = get_global_allowed_permissions()
             if not perms.execute and exec_tools:
-                shared_console.print("[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]")
+                shared_console.print(
+                    "[yellow]⚠️  Warning: Execution tools (e.g., commands, code execution) are disabled. Use -x to enable them.[/yellow]"
+                )
         except Exception as e:
             shared_console.print(f"[red]Error loading tools: {e}[/red]")

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

@@ -1,10 +1,14 @@
 from janito.cli.console import shared_console
 from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
 
+
 class WriteShellHandler(ShellCmdHandler):
     help_text = "/write on|off: Enable or disable write permissions for tools. Usage: /write on or /write off."
 
     def run(self):
+        if self.shell_state and getattr(self.shell_state, 'no_tools_mode', False):
+            shared_console.print("[yellow]No tools are available in this mode (no tools, no context).[/yellow]")
+            return
         if not self.shell_state:
             shared_console.print("[red]Shell state unavailable.[/red]")
             return
@@ -14,23 +18,36 @@ class WriteShellHandler(ShellCmdHandler):
             return
         enable = arg == "on"
         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 = get_global_allowed_permissions()
-            new_perms = ToolPermissions(read=current.read, write=enable, execute=current.execute)
+            new_perms = ToolPermissions(
+                read=current.read, write=enable, execute=current.execute
+            )
             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 write permissions dynamically: {e}[/yellow]")
+            shared_console.print(
+                f"[yellow]Warning: Could not update write permissions 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]Write permissions ENABLED. Tools can now write files and data.[/green]")
+            shared_console.print(
+                "[green]Write permissions ENABLED. Tools can now write files and data.[/green]"
+            )
         else:
-            shared_console.print("[yellow]Write permissions DISABLED. Tools cannot write files/data.[/yellow]")
+            shared_console.print(
+                "[yellow]Write permissions DISABLED. Tools cannot write files/data.[/yellow]"
+            )

janito/cli/chat_mode/shell/input_history.py

@@ -12,7 +12,9 @@ class UserInputHistory:
     """
 
     def __init__(self, history_dir=None):
-        self.history_dir = history_dir or os.path.join(os.path.expanduser("~"), ".janito", "input_history")
+        self.history_dir = history_dir or os.path.join(
+            os.path.expanduser("~"), ".janito", "input_history"
+        )
         os.makedirs(self.history_dir, exist_ok=True)
 
     def _get_today_file(self):

janito/cli/chat_mode/shell/session/manager.py

@@ -38,5 +38,3 @@ def set_role(role):
     rc = RuntimeConfig()
     rc.role = role
     rc.save()
-
-