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

janito/__init__.py

@@ -3,4 +3,4 @@ janito: A Python package for managing and interacting with Large Language Model
 Provides a CLI for credential management and an extensible driver system for LLMs.
 """
 
-__version__ = "2.2.0"
+__version__ = "2.3.1"

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

@@ -1,84 +1,95 @@
-"""
-Utilities for model-related CLI output
-"""
-
-
-def _print_models_table(models, provider_name):
-    from rich.table import Table
-    from rich.console import Console
-
-    headers = [
-        "name",
-        "open",
-        "context",
-        "max_input",
-        "max_cot",
-        "max_response",
-        "thinking_supported",
-        "driver",
-    ]
-    display_headers = [
-        "Model Name",
-        "Vendor",
-        "context",
-        "max_input",
-        "max_cot",
-        "max_response",
-        "Thinking",
-        "Driver",
-    ]
-    table = Table(title=f"Supported models for provider '{provider_name}'")
-    _add_table_columns(table, display_headers)
-    num_fields = {"context", "max_input", "max_cot", "max_response"}
-    for m in models:
-        row = [str(m.get("name", ""))]
-        row.extend(_build_model_row(m, headers, num_fields))
-        table.add_row(*row)
-    console = Console()
-    console.print(table)
-
-
-def _add_table_columns(table, display_headers):
-    for i, h in enumerate(display_headers):
-        justify = "right" if i == 0 else "center"
-        table.add_column(h, style="bold", justify=justify)
-
-
-def _format_k(val):
-    try:
-        n = int(val)
-        if n >= 1000:
-            return f"{n // 1000}k"
-        return str(n)
-    except Exception:
-        return str(val)
-
-
-def _build_model_row(m, headers, num_fields):
-    def format_driver(val):
-        if isinstance(val, (list, tuple)):
-            return ", ".join(val)
-        val_str = str(val)
-        return val_str.removesuffix("ModelDriver").strip()
-
-    row = []
-    for h in headers[1:]:
-        v = m.get(h, "")
-        if h in num_fields and v not in ("", "N/A"):
-            if (
-                h in ("context", "max_input")
-                and isinstance(v, (list, tuple))
-                and len(v) == 2
-            ):
-                row.append(f"{_format_k(v[0])} / {_format_k(v[1])}")
-            else:
-                row.append(_format_k(v))
-        elif h == "open":
-            row.append("Open" if v is True or v == "Open" else "Locked")
-        elif h == "thinking_supported":
-            row.append("📖" if v is True or v == "True" else "")
-        elif h == "driver":
-            row.append(format_driver(v))
-        else:
-            row.append(str(v))
-    return row
+"""
+Utilities for model-related CLI output
+"""
+
+
+def _print_models_table(models, provider_name):
+    from rich.table import Table
+    from rich.console import Console
+
+    headers = [
+        "name",
+        "open",
+        "context",
+        "max_input",
+        "max_cot",
+        "max_response",
+        "thinking_supported",
+        "driver",
+    ]
+    display_headers = [
+        "Model Name",
+        "Vendor",
+        "context",
+        "max_input",
+        "max_cot",
+        "max_response",
+        "Thinking",
+        "Driver",
+    ]
+    table = Table(title=f"Supported models for provider '{provider_name}'")
+    _add_table_columns(table, display_headers)
+    num_fields = {"context", "max_input", "max_cot", "max_response"}
+    for m in models:
+        row = [str(m.get("name", ""))]
+        row.extend(_build_model_row(m, headers, num_fields))
+        table.add_row(*row)
+    import sys
+    if sys.stdout.isatty():
+        from rich.console import Console
+        Console().print(table)
+    else:
+        # ASCII-friendly fallback table when output is redirected
+        print(f"Supported models for provider '{provider_name}'")
+        headers_fallback = [h for h in display_headers]
+        print(' | '.join(headers_fallback))
+        for m in models:
+            row = [str(m.get('name', ''))]
+            row.extend(_build_model_row(m, headers, num_fields))
+            print(' | '.join(row))
+
+
+def _add_table_columns(table, display_headers):
+    for i, h in enumerate(display_headers):
+        justify = "right" if i == 0 else "center"
+        table.add_column(h, style="bold", justify=justify)
+
+
+def _format_k(val):
+    try:
+        n = int(val)
+        if n >= 1000:
+            return f"{n // 1000}k"
+        return str(n)
+    except Exception:
+        return str(val)
+
+
+def _build_model_row(m, headers, num_fields):
+    def format_driver(val):
+        if isinstance(val, (list, tuple)):
+            return ", ".join(val)
+        val_str = str(val)
+        return val_str.removesuffix("ModelDriver").strip()
+
+    row = []
+    for h in headers[1:]:
+        v = m.get(h, "")
+        if h in num_fields and v not in ("", "N/A"):
+            if (
+                h in ("context", "max_input")
+                and isinstance(v, (list, tuple))
+                and len(v) == 2
+            ):
+                row.append(f"{_format_k(v[0])} / {_format_k(v[1])}")
+            else:
+                row.append(_format_k(v))
+        elif h == "open":
+            row.append("Open" if v is True or v == "Open" else "Locked")
+        elif h == "thinking_supported":
+            row.append("📖" if v is True or v == "True" else "")
+        elif h == "driver":
+            row.append(format_driver(v))
+        else:
+            row.append(str(v))
+    return row

janito/cli/config.py

@@ -3,8 +3,9 @@ from janito.config import config
 CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",  # pragma: allowlist secret
     "trust": "Trust mode: suppress all console output (bool, default: False)",
-    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini')",
+    "model": "Model name to use (e.g., 'gpt-4.1', 'gpt-4o', 'gpt-4-turbo', 'o3-mini', 'o4-mini', 'gemini-2.5-flash')",
     "base_url": "API base URL (OpenAI-compatible endpoint)",
+    "azure_deployment_name": "Azure OpenAI deployment name (for Azure endpoints)",
     "role": "Role description for the Agent Profile (e.g., 'software engineer')",
     "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
     "max_tokens": "Maximum tokens for model response (int)",

janito/cli/core/getters.py

@@ -1,31 +1,33 @@
-"""Handlers for get-type CLI commands (show_config, list_providers, models, tools)."""
-
-from janito.cli.cli_commands.list_providers import handle_list_providers
-from janito.cli.cli_commands.list_models import handle_list_models
-from janito.cli.cli_commands.list_tools import handle_list_tools
-from janito.cli.cli_commands.show_config import handle_show_config
-from functools import partial
-from janito.provider_registry import ProviderRegistry
-
-GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
-
-
-def handle_getter(args, config_mgr=None):
-    provider_instance = None
-    if getattr(args, "list_models", False):
-        provider = getattr(args, "provider", None)
-        if not provider:
-            print(
-                "Error: No provider selected. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
-            )
-            return
-        provider_instance = ProviderRegistry().get_instance(provider)
-    GETTER_DISPATCH = {
-        "list_providers": partial(handle_list_providers, args),
-        "list_models": partial(handle_list_models, args, provider_instance),
-        "list_tools": partial(handle_list_tools, args),
-        "show_config": partial(handle_show_config, args),
-    }
-    for arg in GETTER_KEYS:
-        if getattr(args, arg, False) and arg in GETTER_DISPATCH:
-            return GETTER_DISPATCH[arg]()
+"""Handlers for get-type CLI commands (show_config, list_providers, models, tools)."""
+import sys
+
+from janito.cli.cli_commands.list_providers import handle_list_providers
+from janito.cli.cli_commands.list_models import handle_list_models
+from janito.cli.cli_commands.list_tools import handle_list_tools
+from janito.cli.cli_commands.show_config import handle_show_config
+from functools import partial
+from janito.provider_registry import ProviderRegistry
+
+GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
+
+
+def handle_getter(args, config_mgr=None):
+    provider_instance = None
+    if getattr(args, "list_models", False):
+        provider = getattr(args, "provider", None)
+        if not provider:
+            import sys
+            print(
+                "Error: No provider selected. Please set a provider using '-p PROVIDER', '--set provider=name', or configure a provider."
+            )
+            sys.exit(1)
+        provider_instance = ProviderRegistry().get_instance(provider)
+    GETTER_DISPATCH = {
+        "list_providers": partial(handle_list_providers, args),
+        "list_models": partial(handle_list_models, args, provider_instance),
+        "list_tools": partial(handle_list_tools, args),
+        "show_config": partial(handle_show_config, args),
+    }
+    for arg in GETTER_KEYS:
+        if getattr(args, arg, False) and arg in GETTER_DISPATCH:
+            return GETTER_DISPATCH[arg]()