janito 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

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": None, "profile_system_prompt": "You are an helpful assistant"}
+    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/autocomplete.py

@@ -1,21 +1,21 @@
-from prompt_toolkit.completion import Completer, Completion
-from janito.cli.chat_mode.shell.commands import get_shell_command_names
-
-
-class ShellCommandCompleter(Completer):
-    """
-    Provides autocomplete suggestions for shell commands starting with '/'.
-    Uses the COMMAND_HANDLERS registry for available commands.
-    """
-
-    def __init__(self):
-        # Only commands starting with '/'
-        self.commands = get_shell_command_names()
-
-    def get_completions(self, document, complete_event):
-        text = document.text_before_cursor
-        if text.startswith("/"):
-            prefix = text[1:]
-            for cmd in self.commands:
-                if cmd[1:].startswith(prefix):
-                    yield Completion(cmd, start_position=-(len(prefix) + 1))
+from prompt_toolkit.completion import Completer, Completion
+from janito.cli.chat_mode.shell.commands import get_shell_command_names
+
+
+class ShellCommandCompleter(Completer):
+    """
+    Provides autocomplete suggestions for shell commands starting with '/'.
+    Uses the COMMAND_HANDLERS registry for available commands.
+    """
+
+    def __init__(self):
+        # Only commands starting with '/'
+        self.commands = get_shell_command_names()
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith("/"):
+            prefix = text[1:]
+            for cmd in self.commands:
+                if cmd[1:].startswith(prefix):
+                    yield Completion(cmd, start_position=-(len(prefix) + 1))

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

@@ -1,21 +1,26 @@
 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 .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,
+    "/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,7 +28,7 @@ COMMAND_HANDLERS = {
         "janito.cli.chat_mode.shell.commands.conversation_restart",
         fromlist=["RestartShellHandler"],
     ).RestartShellHandler,
-    "/edit": EditShellHandler,
+
     "/view": ViewShellHandler,
     "/lang": LangShellHandler,
     "/livelogs": LivelogsShellHandler,
@@ -31,8 +36,9 @@ COMMAND_HANDLERS = {
     "/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/clear.py

@@ -1,12 +1,12 @@
-from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
-from janito.cli.console import shared_console
-
-
-class ClearShellHandler(ShellCmdHandler):
-    help_text = "Clear the terminal screen using Rich console."
-
-    def run(self):
-        shared_console.clear()
-        # Optionally show a message after clearing
-        # shared_console.print("[green]Screen cleared.[/green]")
-        return None
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class ClearShellHandler(ShellCmdHandler):
+    help_text = "Clear the terminal screen using Rich console."
+
+    def run(self):
+        shared_console.clear()
+        # Optionally show a message after clearing
+        # shared_console.print("[green]Screen cleared.[/green]")
+        return None

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

@@ -37,6 +37,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 +69,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

@@ -6,11 +6,14 @@ 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]")

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

@@ -0,0 +1,28 @@
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+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])"
+
+    def run(self):
+        model_name = self.after_cmd_line.strip()
+        if not model_name:
+            # Show effective model
+            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}")
+            else:
+                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"):
+            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}")
+

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

@@ -1,51 +1,51 @@
-from prompt_toolkit.shortcuts import prompt
-from prompt_toolkit.application.current import get_app
-from prompt_toolkit.document import Document
-from prompt_toolkit.key_binding import KeyBindings
-from janito.cli.console import shared_console
-from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
-
-
-class MultiShellHandler(ShellCmdHandler):
-    help_text = "Prompt for multi-line input and display the result. Usage: /multi"
-
-    def run(self):
-        shared_console.print(
-            "[bold blue]Entering multi-line input mode. Press Esc+Enter or Ctrl+D to submit, Ctrl+C to cancel.[/bold blue]"
-        )
-        # Prompt for multi-line input
-        bindings = KeyBindings()
-        submitted = {"value": None}
-
-        @bindings.add("escape", "enter")
-        def _(event):
-            buffer = event.app.current_buffer
-            submitted["value"] = buffer.text
-            event.app.exit(result=buffer.text)
-
-        # Support Ctrl+D
-        @bindings.add("c-d")
-        def _(event):
-            buffer = event.app.current_buffer
-            submitted["value"] = buffer.text
-            event.app.exit(result=buffer.text)
-
-        try:
-            user_input = prompt(
-                "Multi-line > ",
-                multiline=True,
-                key_bindings=bindings,
-            )
-        except (EOFError, KeyboardInterrupt):
-            shared_console.print("[red]Multi-line input cancelled.[/red]")
-            return
-
-        # Save input to history if available
-        user_input_history = getattr(self.shell_state, "user_input_history", None)
-        if user_input_history is not None:
-            user_input_history.append(user_input)
-        # Store input for main chat loop to consume as if just entered by the user
-        self.shell_state.injected_input = user_input
-        shared_console.print(
-            "[green]Multi-line input will be sent as your next chat prompt.[/green]"
-        )
+from prompt_toolkit.shortcuts import prompt
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.document import Document
+from prompt_toolkit.key_binding import KeyBindings
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class MultiShellHandler(ShellCmdHandler):
+    help_text = "Prompt for multi-line input and display the result. Usage: /multi"
+
+    def run(self):
+        shared_console.print(
+            "[bold blue]Entering multi-line input mode. Press Esc+Enter or Ctrl+D to submit, Ctrl+C to cancel.[/bold blue]"
+        )
+        # Prompt for multi-line input
+        bindings = KeyBindings()
+        submitted = {"value": None}
+
+        @bindings.add("escape", "enter")
+        def _(event):
+            buffer = event.app.current_buffer
+            submitted["value"] = buffer.text
+            event.app.exit(result=buffer.text)
+
+        # Support Ctrl+D
+        @bindings.add("c-d")
+        def _(event):
+            buffer = event.app.current_buffer
+            submitted["value"] = buffer.text
+            event.app.exit(result=buffer.text)
+
+        try:
+            user_input = prompt(
+                "Multi-line > ",
+                multiline=True,
+                key_bindings=bindings,
+            )
+        except (EOFError, KeyboardInterrupt):
+            shared_console.print("[red]Multi-line input cancelled.[/red]")
+            return
+
+        # Save input to history if available
+        user_input_history = getattr(self.shell_state, "user_input_history", None)
+        if user_input_history is not None:
+            user_input_history.append(user_input)
+        # Store input for main chat loop to consume as if just entered by the user
+        self.shell_state.injected_input = user_input
+        shared_console.print(
+            "[green]Multi-line input will be sent as your next chat prompt.[/green]"
+        )

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

@@ -0,0 +1,37 @@
+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 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: /read on|off[/yellow]")
+            return
+        enable = arg == "on"
+        try:
+            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)
+            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]")
+        # 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]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]")

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

@@ -6,37 +6,64 @@ class ToolsShellHandler(ShellCmdHandler):
 
     def run(self):
         try:
-            # Initialize allow_execution before use
-            allow_execution = False
-            if hasattr(self, 'shell_state') and self.shell_state is not None:
-                allow_execution = getattr(self.shell_state, 'allow_execution', False)
 
             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:" if tools else "No tools registered.")
-            # Get tool instances for annotation
+            from rich.table import Table
+            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.")
+                return
+            # Group tools by permission class
+            perm_groups = {}
+            def perm_class(perms):
+                if perms.execute:
+                    if perms.read and perms.write:
+                        return "read-write-execute"
+                    elif perms.read:
+                        return "read-execute"
+                    elif perms.write:
+                        return "write-execute"
+                    else:
+                        return "execute-only"
+                elif perms.read and perms.write:
+                    return "read-write"
+                elif perms.read:
+                    return "read-only"
+                elif perms.write:
+                    return "write-only"
+                else:
+                    return "none"
             for tool in tools:
                 inst = tool_instances.get(tool, None)
-                is_exec = getattr(inst, 'provides_execution', False) if inst else False
-                if is_exec and not allow_execution:
-                    shared_console.print(f"- {tool} (disabled)")
+                perms = getattr(inst, 'permissions', None)
+                if not perms:
+                    group = "unknown"
                 else:
-                    shared_console.print(f"- {tool}")
-
-            if allow_execution:
-                shared_console.print("[green]Execution tools are ENABLED.[/green]")
-            else:
-                shared_console.print("[yellow]Execution tools are DISABLED. Use /exec on to enable them.[/yellow]")
+                    group = perm_class(perms)
+                perm_groups.setdefault(group, []).append(tool)
+            # Build and print table
+            table = Table(title="Tools by Permission Class")
+            table.add_column("Permission Type", style="cyan", no_wrap=True)
+            table.add_column("Tools", style="magenta")
+            for group, tool_list in sorted(perm_groups.items()):
+                table.add_row(group, " ".join(sorted(tool_list)))
+            shared_console.print(table)
 
-            # Find all possible execution tools (by convention: provides_execution = True)
+            
+            # Find all possible execution tools (by permission: execute=True)
             exec_tools = []
             for tool_instance in registry.get_tools():
-                if getattr(tool_instance, 'provides_execution', False):
+                perms = getattr(tool_instance, 'permissions', None)
+                if perms and perms.execute:
                     exec_tools.append(tool_instance.tool_name)
 
-            if not allow_execution and exec_tools:
+            from janito.tools.permissions import get_global_allowed_permissions
+            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]")
 
         except Exception as e:

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

@@ -0,0 +1,37 @@
+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 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: /write on|off[/yellow]")
+            return
+        enable = arg == "on"
+        try:
+            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)
+            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]")
+        # 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]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]")