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

janito/cli/chat_mode/shell/input_history.py

@@ -1,62 +1,62 @@
-import os
-import json
-from datetime import datetime
-from typing import List, Any, Dict
-
-
-class UserInputHistory:
-    """
-    Handles loading, saving, and appending of user input history for the shell.
-    Each day's history is stored in a line-delimited JSONL file (.jsonl) under .janito/input_history/.
-    Each line is a JSON dict, e.g., {"input": ..., "ts": ...}
-    """
-
-    def __init__(self, history_dir=None):
-        self.history_dir = history_dir or os.path.join(".janito", "input_history")
-        os.makedirs(self.history_dir, exist_ok=True)
-
-    def _get_today_file(self):
-        today_str = datetime.now().strftime("%y%m%d")
-        return os.path.join(self.history_dir, f"{today_str}.jsonl")
-
-    def load(self) -> List[Dict[str, Any]]:
-        """Load today's input history as a list of dicts."""
-        history_file = self._get_today_file()
-        history = []
-        try:
-            with open(history_file, "r", encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if not line:
-                        continue
-                    try:
-                        history.append(json.loads(line))
-                    except json.JSONDecodeError:
-                        continue
-        except FileNotFoundError:
-            pass
-        return history
-
-    def sanitize_surrogates(self, s):
-        if isinstance(s, str):
-            return s.encode("utf-8", errors="replace").decode("utf-8")
-        return s
-
-    def append(self, input_str: str):
-        """Append a new input as a JSON dict to today's history file."""
-        history_file = self._get_today_file()
-        input_str = self.sanitize_surrogates(input_str)
-        entry = {"input": input_str, "ts": datetime.now().isoformat()}
-        with open(history_file, "a", encoding="utf-8") as f:
-            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
-
-    def save(self, history_list: List[Any]):
-        """Overwrite today's history file with the given list (for compatibility)."""
-        history_file = self._get_today_file()
-        with open(history_file, "w", encoding="utf-8") as f:
-            for item in history_list:
-                if isinstance(item, dict):
-                    f.write(json.dumps(item, ensure_ascii=False) + "\n")
-                else:
-                    entry = {"input": str(item), "ts": datetime.now().isoformat()}
-                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+import os
+import json
+from datetime import datetime
+from typing import List, Any, Dict
+
+
+class UserInputHistory:
+    """
+    Handles loading, saving, and appending of user input history for the shell.
+    Each day's history is stored in a line-delimited JSONL file (.jsonl) under .janito/input_history/.
+    Each line is a JSON dict, e.g., {"input": ..., "ts": ...}
+    """
+
+    def __init__(self, history_dir=None):
+        self.history_dir = history_dir or os.path.join(".janito", "input_history")
+        os.makedirs(self.history_dir, exist_ok=True)
+
+    def _get_today_file(self):
+        today_str = datetime.now().strftime("%y%m%d")
+        return os.path.join(self.history_dir, f"{today_str}.jsonl")
+
+    def load(self) -> List[Dict[str, Any]]:
+        """Load today's input history as a list of dicts."""
+        history_file = self._get_today_file()
+        history = []
+        try:
+            with open(history_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        history.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        continue
+        except FileNotFoundError:
+            pass
+        return history
+
+    def sanitize_surrogates(self, s):
+        if isinstance(s, str):
+            return s.encode("utf-8", errors="replace").decode("utf-8")
+        return s
+
+    def append(self, input_str: str):
+        """Append a new input as a JSON dict to today's history file."""
+        history_file = self._get_today_file()
+        input_str = self.sanitize_surrogates(input_str)
+        entry = {"input": input_str, "ts": datetime.now().isoformat()}
+        with open(history_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def save(self, history_list: List[Any]):
+        """Overwrite today's history file with the given list (for compatibility)."""
+        history_file = self._get_today_file()
+        with open(history_file, "w", encoding="utf-8") as f:
+            for item in history_list:
+                if isinstance(item, dict):
+                    f.write(json.dumps(item, ensure_ascii=False) + "\n")
+                else:
+                    entry = {"input": str(item), "ts": datetime.now().isoformat()}
+                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")

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_models.py

@@ -1,35 +1,35 @@
-"""
-CLI Command: List models for the specified/current provider
-"""
-
-from janito.cli.cli_commands.model_utils import _print_models_table
-import sys
-
-_provider_instance = None
-
-
-def get_provider_instance():
-    global _provider_instance
-    if _provider_instance is None:
-        _provider_instance = setup_provider()
-    return _provider_instance
-
-
-def handle_list_models(args, provider_instance):
-    provider_name = getattr(provider_instance, "name", None)
-    if not provider_name:
-        print(
-            "Error: Provider must be specified with --provider or set as default before listing models."
-        )
-        sys.exit(1)
-    try:
-        models = list(provider_instance.get_model_info().values())
-        if models and isinstance(models[0], dict):
-            _print_models_table(models, provider_name)
-        else:
-            print(f"Supported models for provider '{provider_name}':")
-            for m in models:
-                print(f"- {m}")
-    except Exception as e:
-        print(f"Error listing models for provider '{provider_name}': {e}")
-    sys.exit(0)
+"""
+CLI Command: List models for the specified/current provider
+"""
+
+from janito.cli.cli_commands.model_utils import _print_models_table
+import sys
+
+_provider_instance = None
+
+
+def get_provider_instance():
+    global _provider_instance
+    if _provider_instance is None:
+        _provider_instance = setup_provider()
+    return _provider_instance
+
+
+def handle_list_models(args, provider_instance):
+    provider_name = getattr(provider_instance, "name", None)
+    if not provider_name:
+        print(
+            "Error: Provider must be specified with --provider or set as default before listing models."
+        )
+        sys.exit(1)
+    try:
+        models = list(provider_instance.get_model_info().values())
+        if models and isinstance(models[0], dict):
+            _print_models_table(models, provider_name)
+        else:
+            print(f"Supported models for provider '{provider_name}':")
+            for m in models:
+                print(f"- {m}")
+    except Exception as e:
+        print(f"Error listing models for provider '{provider_name}': {e}")
+    sys.exit(0)

janito/cli/cli_commands/list_providers.py

@@ -1,9 +1,9 @@
-"""
-CLI Command: List supported LLM providers
-"""
-
-from janito.provider_registry import list_providers
-
-
-def handle_list_providers(args=None):
-    list_providers()
+"""
+CLI Command: List supported LLM providers
+"""
+
+from janito.provider_registry import list_providers
+
+
+def handle_list_providers(args=None):
+    list_providers()

janito/cli/cli_commands/list_tools.py

@@ -1,53 +1,86 @@
-"""
-CLI Command: List available tools
-"""
-
-
-def handle_list_tools(args=None):
-    from janito.tools.adapters.local.adapter import LocalToolsAdapter
-    import janito.tools  # Ensure all tools are registered
-
-    registry = janito.tools.get_local_tools_adapter()
-    tools = registry.list_tools()
-    if tools:
-        from rich.table import Table
-        from rich.console import Console
-        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 = []
-        exec_tools = []
-        for tool in tools:
-            inst = tool_instances.get(tool, None)
-            # Extract parameter names from run signature
-            param_names = []
-            if inst and hasattr(inst, "run"):
-                import inspect
-                sig = inspect.signature(inst.run)
-                param_names = [p for p in sig.parameters if p != "self"]
-            info = {
-                "name": tool,
-                "params": ", ".join(param_names),
-            }
-            if getattr(inst, "provides_execution", False):
-                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)
-        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.add_column("Name", style="cyan", no_wrap=True)
-            exec_table.add_column("Parameters", style="yellow")
-            for info in exec_tools:
-                exec_table.add_row(info["name"], info["params"] or "-")
-            console.print(exec_table)
-    else:
-        print("No tools registered.")
-    import sys
-
-    sys.exit(0)
+"""
+CLI Command: List available tools
+"""
+
+
+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:
+        from rich.table import Table
+        from rich.console import Console
+        console = Console()
+        # Get tool instances to check provides_execution and get info
+        tool_instances = {t.tool_name: t for t in registry.get_tools()}
+        read_only_tools = []
+        write_only_tools = []
+        read_write_tools = []
+        exec_tools = []
+        for tool in tools:
+            inst = tool_instances.get(tool, None)
+            # Extract parameter names from run signature
+            param_names = []
+            if inst and hasattr(inst, "run"):
+                import inspect
+                sig = inspect.signature(inst.run)
+                param_names = [p for p in sig.parameters if p != "self"]
+            info = {
+                "name": tool,
+                "params": ", ".join(param_names),
+            }
+            perms = getattr(inst, "permissions", None)
+            if perms and perms.execute:
+                exec_tools.append(info)
+            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 (-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:
+                exec_table.add_row(info["name"], info["params"] or "-")
+            console.print(exec_table)
+    else:
+        print("No tools registered.")
+    import sys
+
+    sys.exit(0)

janito/cli/cli_commands/model_selection.py

@@ -1,50 +1,50 @@
-"""
-CLI Command: Validate and set the model provider selection
-"""
-
-from janito.cli.config import config
-
-_provider_instance = None
-
-
-def get_provider_instance():
-    global _provider_instance
-    if _provider_instance is None:
-        _provider_instance = setup_provider()
-    return _provider_instance
-
-
-def handle_model_selection(args):
-    if getattr(args, "model", None):
-        provider_instance = get_provider_instance()
-        provider_name = getattr(provider_instance, "name", None)
-        if not provider_name:
-            print(
-                "Error: Provider must be specified with --provider or set as default before selecting a model."
-            )
-            import sys
-
-            sys.exit(1)
-        if not validate_model_for_provider(provider_name, args.model):
-            sys.exit(1)
-        config.runtime_set("model", args.model)
-
-
-def validate_model_for_provider(provider_name, model_name):
-    try:
-        provider_instance = get_provider_instance()
-        info_dict = provider_instance.get_model_info()
-        available_names = [
-            m["name"] for m in info_dict.values() if isinstance(m, dict) and "name" in m
-        ]
-        if model_name in available_names:
-            return True
-        else:
-            print(
-                f"Error: Model '{model_name}' is not available for provider '{provider_name}'."
-            )
-            print(f"Available models: {', '.join(available_names)}")
-            return False
-    except Exception as e:
-        print(f"Error validating model for provider '{provider_name}': {e}")
-        return False
+"""
+CLI Command: Validate and set the model provider selection
+"""
+
+from janito.cli.config import config
+
+_provider_instance = None
+
+
+def get_provider_instance():
+    global _provider_instance
+    if _provider_instance is None:
+        _provider_instance = setup_provider()
+    return _provider_instance
+
+
+def handle_model_selection(args):
+    if getattr(args, "model", None):
+        provider_instance = get_provider_instance()
+        provider_name = getattr(provider_instance, "name", None)
+        if not provider_name:
+            print(
+                "Error: Provider must be specified with --provider or set as default before selecting a model."
+            )
+            import sys
+
+            sys.exit(1)
+        if not validate_model_for_provider(provider_name, args.model):
+            sys.exit(1)
+        config.runtime_set("model", args.model)
+
+
+def validate_model_for_provider(provider_name, model_name):
+    try:
+        provider_instance = get_provider_instance()
+        info_dict = provider_instance.get_model_info()
+        available_names = [
+            m["name"] for m in info_dict.values() if isinstance(m, dict) and "name" in m
+        ]
+        if model_name in available_names:
+            return True
+        else:
+            print(
+                f"Error: Model '{model_name}' is not available for provider '{provider_name}'."
+            )
+            print(f"Available models: {', '.join(available_names)}")
+            return False
+    except Exception as e:
+        print(f"Error validating model for provider '{provider_name}': {e}")
+        return False

janito/cli/cli_commands/set_api_key.py

@@ -1,19 +1,19 @@
-"""
-CLI Command: Set API key for the current or selected provider
-"""
-
-from janito.provider_config import set_api_key
-from janito.llm.auth import LLMAuthManager
-
-
-def handle_set_api_key(args):
-    api_key = getattr(args, "set_api_key", None)
-    provider = getattr(args, "provider", None)
-    if not provider:
-        print("Error: --set-api-key requires -p/--provider to be specified.")
-        return
-    set_api_key(provider, api_key)
-    auth_manager = LLMAuthManager()
-    print(
-        f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
-    )
+"""
+CLI Command: Set API key for the current or selected provider
+"""
+
+from janito.provider_config import set_api_key
+from janito.llm.auth import LLMAuthManager
+
+
+def handle_set_api_key(args):
+    api_key = getattr(args, "set_api_key", None)
+    provider = getattr(args, "provider", None)
+    if not provider:
+        print("Error: --set-api-key requires -p/--provider to be specified.")
+        return
+    set_api_key(provider, api_key)
+    auth_manager = LLMAuthManager()
+    print(
+        f"API key set for provider '{provider}'. Auth file updated: {auth_manager._auth_file}"
+    )