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

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/prompt.py

@@ -54,11 +54,3 @@ class RoleShellHandler(ShellCmdHandler):
         )
 
 
-class ProfileShellHandler(ShellCmdHandler):
-    help_text = (
-        "Show the current and available Agent Profile (only 'base' is supported)"
-    )
-
-    def run(self):
-        shared_console.print("[bold green]Current profile:[/bold green] base")
-        shared_console.print("[bold yellow]Available profiles:[/bold yellow]\n- base")

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

janito/cli/chat_mode/shell/input_history.py

@@ -12,7 +12,7 @@ class UserInputHistory:
     """
 
     def __init__(self, history_dir=None):
-        self.history_dir = history_dir or os.path.join(".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

@@ -40,71 +40,3 @@ def set_role(role):
     rc.save()
 
 
-def load_last_summary(path=".janito/last_conversation.json"):
-    if not os.path.exists(path):
-        return None
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    return data
-
-
-def load_last_conversation(path=".janito/last_conversation.json"):
-    if not os.path.exists(path):
-        return [], [], None
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    messages = data.get("messages", [])
-    prompts = data.get("prompts", [])
-    usage = data.get("last_usage_info")
-    return messages, prompts, usage
-
-
-def load_conversation_by_session_id(session_id):
-    path = os.path.join(".janito", "chat_history", f"{session_id}.json")
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"Session file not found: {path}")
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    messages = data.get("messages", [])
-    prompts = data.get("prompts", [])
-    usage = data.get("last_usage_info")
-    return messages, prompts, usage
-
-
-def save_conversation(messages, prompts, usage_info=None, path=None):
-    # Do not save if only one message and it is a system message (noop session)
-    if (
-        isinstance(messages, list)
-        and len(messages) == 1
-        and messages[0].get("role") == "system"
-    ):
-        return
-
-    if path is None:
-        session_id = get_session_id()
-        path = os.path.join(".janito", "chat_history", f"{session_id}.json")
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    data = {"messages": messages, "prompts": prompts, "last_usage_info": usage_info}
-
-    def usage_serializer(obj):
-        if hasattr(obj, "to_dict"):
-            return obj.to_dict()
-        if hasattr(obj, "__dict"):
-            return obj.__dict__
-        return str(obj)
-
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, default=usage_serializer)
-        f.write("\n")
-
-
-def last_conversation_exists(path=".janito/last_conversation.json"):
-    if not os.path.exists(path):
-        return False
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            data = json.load(f)
-        messages = data.get("messages", [])
-        return bool(messages)
-    except Exception:
-        return False

janito/cli/chat_mode/toolbar.py

@@ -1,7 +1,7 @@
 from prompt_toolkit.formatted_text import HTML
 from janito.performance_collector import PerformanceCollector
 from janito.cli.config import config
-from janito.version import __version__ as VERSION
+from janito import __version__ as VERSION
 
 
 def format_tokens(n, tag=None):
@@ -20,11 +20,22 @@ def assemble_first_line(provider_name, model_name, role, agent=None):
     return f" Janito {VERSION} | Provider: <provider>{provider_name}</provider> | Model: <model>{model_name}</model> | Role: <role>{role}</role>"
 
 
-def assemble_bindings_line(width):
+def assemble_bindings_line(width, permissions=None):
+    # permissions: ToolPermissions or None
+    def color_state(state):
+        if state == "on":
+            return 'on '
+        else:
+            return 'off'
+    read_state = color_state("on" if getattr(permissions, "read", False) else "off")
+    write_state = color_state("on" if getattr(permissions, "write", False) else "off")
+    execute_state = color_state("on" if getattr(permissions, "execute", False) else "off")
     return (
-        f" <key-label>CTRL-C</key-label>: Interrupt Request/Exit Shell | "
-        f"<key-label>F1</key-label>: Restart conversation | "
-        f"<key-label>F2</key-label>: Exec | "
+        f" <key-label>CTRL-C</key-label>: Interrupt/Exit | "
+        f"<key-label>F1</key-label>: /restart | "
+                f"<key-label>F2</key-label>: <key-toggle-{('on' if not getattr(permissions, 'read', False) else 'off')}>/read {'on ' if not getattr(permissions, 'read', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'read', False) else 'off')}> | "
+                f"<key-label>F3</key-label>: <key-toggle-{('on' if not getattr(permissions, 'write', False) else 'off')}>/write {'on ' if not getattr(permissions, 'write', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'write', False) else 'off')}> | "
+                f"<key-label>F4</key-label>: <key-toggle-{('on' if not getattr(permissions, 'execute', False) else 'off')}>/execute {'on ' if not getattr(permissions, 'execute', False) else 'off'}</key-toggle-{('on' if not getattr(permissions, 'execute', False) else 'off')}> | "
         f"<b>/help</b>: Help | "
         f"<key-label>F12</key-label>: Do It "
     )
@@ -40,29 +51,29 @@ def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
         model_name = "?"
         role = "?"
         agent = shell_state.agent if hasattr(shell_state, "agent") else None
-        termweb_support = getattr(shell_state, "termweb_support", False)
-        termweb_port = (
-            shell_state.termweb_port if hasattr(shell_state, "termweb_port") else None
+        _support = getattr(shell_state, "_support", False)
+        _port = (
+            shell_state._port if hasattr(shell_state, "_port") else None
         )
-        termweb_status = (
-            shell_state.termweb_status
-            if hasattr(shell_state, "termweb_status")
+        _status = (
+            shell_state._status
+            if hasattr(shell_state, "_status")
             else None
         )
         # Use cached liveness check only (set by background thread in shell_state)
-        this_termweb_status = termweb_status
-        if not termweb_support:
-            this_termweb_status = None
-        elif termweb_status == "starting" or termweb_status is None:
-            this_termweb_status = termweb_status
+        this__status = _status
+        if not _support:
+            this__status = None
+        elif _status == "starting" or _status is None:
+            this__status = _status
         else:
             live_status = (
-                shell_state.termweb_live_status
-                if hasattr(shell_state, "termweb_live_status")
+                shell_state._live_status
+                if hasattr(shell_state, "_live_status")
                 else None
             )
             if live_status is not None:
-                this_termweb_status = live_status
+                this__status = live_status
         if agent is not None:
             # Use agent API to get provider and model name
             provider_name = (
@@ -78,15 +89,21 @@ def get_toolbar_func(perf: PerformanceCollector, msg_count: int, shell_state):
         usage = perf.get_last_request_usage()
         first_line = assemble_first_line(provider_name, model_name, role, agent=agent)
 
-        bindings_line = assemble_bindings_line(width)
+        # Get current permissions for toolbar state
+        try:
+            from janito.tools.permissions import get_global_allowed_permissions
+            permissions = get_global_allowed_permissions()
+        except Exception:
+            permissions = None
+        bindings_line = assemble_bindings_line(width, permissions)
         toolbar_text = first_line + "\n" + bindings_line
-        # Add termweb status if available, after the F12 line
-        if this_termweb_status == "online" and termweb_port:
-            toolbar_text += f"\n<termweb> Termweb </termweb>Online<termweb> at <u>http://localhost:{termweb_port}</u></termweb>"
-        elif this_termweb_status == "starting":
-            toolbar_text += "\n<termweb> Termweb </termweb>Starting"
-        elif this_termweb_status == "offline":
-            toolbar_text += "\n<termweb> Termweb </termweb>Offline"
+        # Add  status if available, after the F12 line
+        if this__status == "online" and _port:
+            toolbar_text += f"\n<> Termweb </>Online"
+        elif this__status == "starting":
+            toolbar_text += "\n<> Termweb </>Starting"
+        elif this__status == "offline":
+            toolbar_text += "\n<> Termweb </>Offline"
         return HTML(toolbar_text)
 
     return get_toolbar

janito/cli/cli_commands/list_tools.py

@@ -7,6 +7,16 @@ def handle_list_tools(args=None):
     from janito.tools.adapters.local.adapter import LocalToolsAdapter
     import janito.tools  # Ensure all tools are registered
 
+    # Determine permissions from args (default: all False)
+    from janito.tools.tool_base import ToolPermissions
+    read = getattr(args, "read", False) if args else False
+    write = getattr(args, "write", False) if args else False
+    execute = getattr(args, "exec", False) if args else False
+    # If no permissions are specified, assume user wants to list all tools
+    if not (read or write or execute):
+        read = write = execute = True
+    from janito.tools.permissions import set_global_allowed_permissions
+    set_global_allowed_permissions(ToolPermissions(read=read, write=write, execute=execute))
     registry = janito.tools.get_local_tools_adapter()
     tools = registry.list_tools()
     if tools:
@@ -15,7 +25,9 @@ def handle_list_tools(args=None):
         console = Console()
         # Get tool instances to check provides_execution and get info
         tool_instances = {t.tool_name: t for t in registry.get_tools()}
-        normal_tools = []
+        read_only_tools = []
+        write_only_tools = []
+        read_write_tools = []
         exec_tools = []
         for tool in tools:
             inst = tool_instances.get(tool, None)
@@ -29,18 +41,39 @@ def handle_list_tools(args=None):
                 "name": tool,
                 "params": ", ".join(param_names),
             }
-            if getattr(inst, "provides_execution", False):
+            perms = getattr(inst, "permissions", None)
+            if perms and perms.execute:
                 exec_tools.append(info)
-            else:
-                normal_tools.append(info)
-        table = Table(title="Registered tools", show_header=True, header_style="bold", show_lines=False, box=None)
-        table.add_column("Name", style="cyan", no_wrap=True)
-        table.add_column("Parameters", style="yellow")
-        for info in normal_tools:
-            table.add_row(info["name"], info["params"] or "-")
-        console.print(table)
+            elif perms and perms.read and perms.write:
+                read_write_tools.append(info)
+            elif perms and perms.read:
+                read_only_tools.append(info)
+            elif perms and perms.write:
+                write_only_tools.append(info)
+        # Print each group if not empty
+        if read_only_tools:
+            table = Table(title="Read-only tools (-r)", show_header=True, header_style="bold", show_lines=False, box=None)
+            table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Parameters", style="yellow")
+            for info in read_only_tools:
+                table.add_row(info["name"], info["params"] or "-")
+            console.print(table)
+        if write_only_tools:
+            table = Table(title="Write-only tools (-w)", show_header=True, header_style="bold", show_lines=False, box=None)
+            table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Parameters", style="yellow")
+            for info in write_only_tools:
+                table.add_row(info["name"], info["params"] or "-")
+            console.print(table)
+        if read_write_tools:
+            table = Table(title="Read-Write tools (-rw)", show_header=True, header_style="bold", show_lines=False, box=None)
+            table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Parameters", style="yellow")
+            for info in read_write_tools:
+                table.add_row(info["name"], info["params"] or "-")
+            console.print(table)
         if exec_tools:
-            exec_table = Table(title="Execution tools (only available with -x)", show_header=True, header_style="bold", show_lines=False, box=None)
+            exec_table = Table(title="Execution tools (-x)", show_header=True, header_style="bold", show_lines=False, box=None)
             exec_table.add_column("Name", style="cyan", no_wrap=True)
             exec_table.add_column("Parameters", style="yellow")
             for info in exec_tools: