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

janito/__init__.py

@@ -1,6 +1,6 @@
-"""
-janito: A Python package for managing and interacting with Large Language Model (LLM) providers and their APIs.
-Provides a CLI for credential management and an extensible driver system for LLMs.
-"""
-
-__version__ = "2.2.0"
+"""
+janito: A Python package for managing and interacting with Large Language Model (LLM) providers and their APIs.
+Provides a CLI for credential management and an extensible driver system for LLMs.
+"""
+
+__version__ = "2.3.0"

janito/agent/setup_agent.py

@@ -20,6 +20,7 @@ def setup_agent(
     output_queue=None,
     verbose_tools=False,
     verbose_agent=False,
+    exec_enabled=False,
 ):
     """
     Creates an agent using a rendered system prompt template, passing an explicit role.
@@ -62,17 +63,23 @@ def setup_agent(
                 f"Template file not found in either {template_path} or package resource."
             )
 
+    import time
     template = Template(template_content)
     # Prepare context for Jinja2 rendering from llm_driver_config
     # Compose context for Jinja2 rendering without using to_dict or temperature
     context = {}
     context["role"] = role or "software developer"
-    # Inject current platform environment information
-    pd = PlatformDiscovery()
-    context["platform"] = pd.get_platform_name()
-    context["python_version"] = pd.get_python_version()
-    context["shell_info"] = pd.detect_shell()
+    # Inject current platform environment information only if exec_enabled
+    context["exec_enabled"] = bool(exec_enabled)
+    if exec_enabled:
+        pd = PlatformDiscovery()
+        context["platform"] = pd.get_platform_name()
+        context["python_version"] = pd.get_python_version()
+        context["shell_info"] = pd.detect_shell()
+    start_render = time.time()
     rendered_prompt = template.render(**context)
+    end_render = time.time()
+    
     # Create the agent as before, now passing the explicit role
     # Do NOT pass temperature; do not depend on to_dict
     agent = LLMAgent(
@@ -97,6 +104,7 @@ def create_configured_agent(
     verbose_agent=False,
     templates_dir=None,
     zero_mode=False,
+    exec_enabled=False,
 ):
     """
     Normalizes agent setup for all CLI modes.
@@ -133,6 +141,7 @@ def create_configured_agent(
         output_queue=output_queue,
         verbose_tools=verbose_tools,
         verbose_agent=verbose_agent,
+        exec_enabled=exec_enabled,
     )
     if driver is not None:
         agent.driver = driver  # Attach driver to agent for thread management

janito/agent/templates/profiles/system_prompt_template_main.txt.j2

@@ -6,11 +6,13 @@ You are: {{ role }}
 You will answer following a pattern of: discovery, description, implementation (when a change is requested) and validation.
 
 {# Improves tool selection and platform specific constrains, eg, path format, C:\ vs /path #}
+{% if exec_enabled %}
 You will be using the following environment:
  Platform: {{ platform }}
  Python version: {{ python_version }}
  Shell/Environment: {{ shell_info }}
- 
+ {% endif %}
+
 Before answering map the questions to artifacts found in the current directory - the current project.
 
 Respond according to the following guidelines:

janito/cli/chat_mode/bindings.py

@@ -28,6 +28,12 @@ class KeyBindingsFactory:
             buf.text = "/restart"
             buf.validate_and_handle()
 
+        @bindings.add("f2")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "/exec on"
+            buf.validate_and_handle()
+
         @bindings.add("f12")
         def _(event):
             buf = event.app.current_buffer

janito/cli/chat_mode/session.py

@@ -20,6 +20,7 @@ from janito.cli.chat_mode.shell.autocomplete import ShellCommandCompleter
 
 class ChatShellState:
     def __init__(self, mem_history, conversation_history):
+        self.allow_execution = False  # Controls whether execution tools are enabled
         self.mem_history = mem_history
         self.conversation_history = conversation_history
         self.paste_mode = False
@@ -52,7 +53,13 @@ class ChatSession:
         args=None,
         verbose_tools=False,
         verbose_agent=False,
+        exec_enabled=False
     ):
+        # Set allow_execution from exec_enabled or args
+        if args is not None and hasattr(args, "exec"):
+            allow_execution = bool(getattr(args, "exec", False))
+        else:
+            allow_execution = exec_enabled
         from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
 
         self._prompt_handler = GenericPromptHandler(
@@ -82,12 +89,21 @@ class ChatSession:
             role=role,
             verbose_tools=verbose_tools,
             verbose_agent=verbose_agent,
+            exec_enabled=allow_execution
         )
         from janito.conversation_history import LLMConversationHistory
 
         self.shell_state = ChatShellState(self.mem_history, LLMConversationHistory())
         self.shell_state.agent = agent
+        self.shell_state.allow_execution = allow_execution
         self.agent = agent
+        # Filter execution tools at startup
+        try:
+            registry = getattr(__import__('janito.tools', fromlist=['get_local_tools_adapter']), 'get_local_tools_adapter')()
+            if hasattr(registry, 'set_execution_tools_enabled'):
+                registry.set_execution_tools_enabled(allow_execution)
+        except Exception as e:
+            self.console.print(f"[yellow]Warning: Could not filter execution tools at startup: {e}[/yellow]")
         from janito.perf_singleton import performance_collector
 
         self.performance_collector = performance_collector

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

@@ -13,6 +13,9 @@ 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,
     "/clear": __import__(
         "janito.cli.chat_mode.shell.commands.clear", fromlist=["ClearShellHandler"]
     ).ClearShellHandler,

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

@@ -0,0 +1,27 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+class ExecShellHandler(ShellCmdHandler):
+    help_text = "/exec on|off: Enable or disable code and command execution tools. Usage: /exec on or /exec 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: /exec on|off[/yellow]")
+            return
+        enable = arg == "on"
+        self.shell_state.allow_execution = enable
+        # Dynamically enable/disable execution tools in the registry
+        try:
+            registry = __import__('janito.tools', fromlist=['get_local_tools_adapter']).get_local_tools_adapter()
+            if hasattr(registry, 'set_execution_tools_enabled'):
+                registry.set_execution_tools_enabled(enable)
+        except Exception as e:
+            shared_console.print(f"[yellow]Warning: Could not update execution tools dynamically: {e}[/yellow]")
+        if enable:
+            shared_console.print("[green]Execution tools ENABLED. You can now use code and command execution tools.[/green]")
+        else:
+            shared_console.print("[yellow]Execution tools DISABLED. Code and command execution tools are now blocked.[/yellow]")

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

@@ -6,18 +6,29 @@ 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
             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
+            tool_instances = {t.tool_name: t for t in registry.get_tools()}
             for tool in tools:
-                shared_console.print(f"- {tool}")
+                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)")
+                else:
+                    shared_console.print(f"- {tool}")
 
-            # Check for execution tools
-            # We assume shell_state.allow_execution is set if -x is used
-            allow_execution = False
-            if hasattr(self, 'shell_state') and self.shell_state is not None:
-                allow_execution = getattr(self.shell_state, 'allow_execution', False)
+            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]")
 
             # Find all possible execution tools (by convention: provides_execution = True)
             exec_tools = []

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/shell/session/manager.py

@@ -95,6 +95,7 @@ def save_conversation(messages, prompts, usage_info=None, path=None):
 
     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"):

janito/cli/chat_mode/toolbar.py

@@ -24,6 +24,7 @@ def assemble_bindings_line(width):
     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"<b>/help</b>: Help | "
         f"<key-label>F12</key-label>: Do It "
     )

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()