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

janito/cli/cli_commands/model_utils.py

@@ -1,95 +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)
-    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
+"""
+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/cli_commands/show_system_prompt.py

@@ -1,5 +1,7 @@
 """
 CLI Command: Show the resolved system prompt for the main agent (single-shot mode)
+
+Supports --profile to select a profile-specific system prompt template.
 """
 
 from janito.cli.core.runner import prepare_llm_driver_config
@@ -23,39 +25,80 @@ def handle_show_system_prompt(args):
 
     # Prepare context for Jinja2 rendering
     context = {}
-    context["role"] = agent_role or "software developer"
-    pd = PlatformDiscovery()
-    context["platform"] = pd.get_platform_name()
-    context["python_version"] = pd.get_python_version()
-    context["shell_info"] = pd.detect_shell()
+    context["role"] = agent_role or "developer"
+    context["profile"] = getattr(args, "profile", None)
+    # Compute allowed_permissions from CLI args (as in agent setup)
+    from janito.tools.tool_base import ToolPermissions
+    read = getattr(args, "read", False)
+    write = getattr(args, "write", False)
+    execute = getattr(args, "exec", False)
+    allowed = ToolPermissions(read=read, write=write, execute=execute)
+    perm_str = ""
+    if allowed.read:
+        perm_str += "r"
+    if allowed.write:
+        perm_str += "w"
+    if allowed.execute:
+        perm_str += "x"
+    allowed_permissions = perm_str or None
+    context["allowed_permissions"] = allowed_permissions
+    # DEBUG: Show permissions/context before rendering
+    from rich import print as rich_print
+    debug_flag = False
+    import sys
+    try:
+        debug_flag = (hasattr(sys, 'argv') and ('--debug' in sys.argv or '--verbose' in sys.argv or '-v' in sys.argv))
+    except Exception:
+        pass
+    if debug_flag:
+        rich_print(f"[bold magenta][DEBUG][/bold magenta] Rendering system prompt template '[cyan]{template_filename}[/cyan]' with allowed_permissions: [yellow]{allowed_permissions}[/yellow]")
+        rich_print(f"[bold magenta][DEBUG][/bold magenta] Template context: [green]{context}[/green]")
+    if allowed_permissions and 'x' in allowed_permissions:
+        pd = PlatformDiscovery()
+        context["platform"] = pd.get_platform_name()
+        context["python_version"] = pd.get_python_version()
+        context["shell_info"] = pd.detect_shell()
 
     # Locate and load the system prompt template
     templates_dir = (
         Path(__file__).parent.parent.parent / "agent" / "templates" / "profiles"
     )
-    template_path = templates_dir / "system_prompt_template_main.txt.j2"
+    profile = getattr(args, "profile", None)
+    if profile:
+        template_filename = f"system_prompt_template_{profile}.txt.j2"
+        template_path = templates_dir / template_filename
+    else:
+        # No profile specified means the main agent has no dedicated system prompt template.
+        print("[janito] No profile specified. The main agent runs without a system prompt template.\n"
+              "Use --profile PROFILE to view a profile-specific system prompt.")
+        return
     template_content = None
-    if template_path.exists():
+    if template_path and template_path.exists():
         with open(template_path, "r", encoding="utf-8") as file:
             template_content = file.read()
     else:
         # Try package import fallback
         try:
             with importlib.resources.files("janito.agent.templates.profiles").joinpath(
-                "system_prompt_template_main.txt.j2"
+                template_filename
             ).open("r", encoding="utf-8") as file:
                 template_content = file.read()
         except (FileNotFoundError, ModuleNotFoundError, AttributeError):
-            print(
-                f"[janito] Could not find system_prompt_template_main.txt.j2 in {template_path} nor in janito.agent.templates.profiles package."
-            )
-            print("No system prompt is set or resolved for this configuration.")
-            return
+            if profile:
+                raise FileNotFoundError(
+                    f"[janito] Could not find profile-specific template '{template_filename}' in {template_path} nor in janito.agent.templates.profiles package."
+                )
+            else:
+                print(
+                    f"[janito] Could not find {template_filename} in {template_path} nor in janito.agent.templates.profiles package."
+                )
+                print("No system prompt is set or resolved for this configuration.")
+                return
 
     template = Template(template_content)
     system_prompt = template.render(**context)
 
-    print("\n--- System Prompt (resolved) ---\n")
+    print(f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n")
     print(system_prompt)
     print("\n-------------------------------\n")
     if agent_role:

janito/cli/config.py

@@ -13,16 +13,15 @@ CONFIG_OPTIONS = {
     "profile": "Agent Profile name (only 'base' is supported)",
 }
 
-DEFAULT_TERMWEB_PORT = 8088
 
 
-def get_termweb_port():
-    port = config.get("termweb_port")
+def get__port():
+    port = config.get("_port")
     try:
         return int(port)
     except Exception:
-        return DEFAULT_TERMWEB_PORT
+        pass
 
 
-def set_termweb_port(port):
-    config.file_set("termweb_port", int(port))
+def set__port(port):
+    config.file_set("_port", int(port))

janito/cli/core/getters.py

@@ -1,33 +1,33 @@
-"""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]()
+"""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]()

janito/cli/core/runner.py

@@ -92,11 +92,11 @@ def prepare_llm_driver_config(args, modifiers):
     llm_driver_config = LLMDriverConfig(**driver_config_data)
     if getattr(llm_driver_config, "verbose_api", None):
         pass
-    agent_role = modifiers.get("role", "software developer")
+    agent_role = modifiers.get("role", "developer")
     return provider, llm_driver_config, agent_role
 
 
-def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, exec_enabled=False):
+def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=False, ):
     """
     Main runner for CLI execution. If exec_enabled is False, disables execution/run tools.
     """
@@ -105,23 +105,26 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
 
     # Patch: disable execution/run tools if not enabled
     import janito.tools
+    from janito.tools.tool_base import ToolPermissions
+    read = getattr(args, "read", False)
+    write = getattr(args, "write", False)
+    execute = getattr(args, "exec", False)
+    from janito.tools.permissions import set_global_allowed_permissions
+    from janito.tools.tool_base import ToolPermissions
+    allowed_permissions = ToolPermissions(read=read, write=write, execute=execute)
+    set_global_allowed_permissions(allowed_permissions)
+    # Store the default permissions for later restoration (e.g., on /restart)
+    from janito.tools.permissions import set_default_allowed_permissions
+    set_default_allowed_permissions(allowed_permissions)
     adapter = janito.tools.get_local_tools_adapter(workdir=getattr(args, "workdir", None))
-    if not exec_enabled:
-        if hasattr(adapter, "disable_execution_tools"):
-            adapter.disable_execution_tools()
-    else:
-        # Try to re-register execution tools if possible (print warning if not supported)
-        if hasattr(adapter, "register_tool"):
-            # This is a no-op if already registered, but we can attempt to re-register known execution tools
-            try:
-                from janito.tools.adapters.local import PythonCodeRunTool, PythonCommandRunTool, PythonFileRunTool, RunBashCommandTool, RunPowershellCommandTool
-                for tool_cls in [PythonCodeRunTool, PythonCommandRunTool, PythonFileRunTool, RunBashCommandTool, RunPowershellCommandTool]:
-                    try:
-                        adapter.register_tool(tool_cls)
-                    except Exception:
-                        pass  # Already registered or error
-            except Exception:
-                pass
+
+    # Print allowed permissions in verbose mode
+    if getattr(args, "verbose", False):
+        print_verbose_info(
+            "Allowed Tool Permissions",
+            f"read={read}, write={write}, execute={execute}",
+            style="yellow"
+        )
 
     provider_instance = ProviderRegistry().get_instance(provider, llm_driver_config)
     if provider_instance is None:
@@ -140,7 +143,10 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
         # DEBUG: Print exec_enabled propagation at runner
         
         handler = SingleShotPromptHandler(
-            args, provider_instance, llm_driver_config, role=agent_role, exec_enabled=exec_enabled
+            args, provider_instance, llm_driver_config,
+            role=agent_role,
+            
+            allowed_permissions=allowed_permissions,
         )
         handler.handle()
     else:
@@ -156,7 +162,8 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
             args=args,
             verbose_tools=verbose_tools,
             verbose_agent=getattr(args, "verbose_agent", False),
-            exec_enabled=exec_enabled,
+            
+            allowed_permissions=allowed_permissions,
         )
         session.run()
 

janito/cli/core/setters.py

@@ -43,8 +43,17 @@ def handle_set(args, config_mgr=None):
             return True
         if ".max_tokens" in key or ".base_url" in key:
             return _handle_set_provider_level_setting(key, value)
+        # Tool permissions support: janito set tool_permissions=rwx
+        if key == "tool_permissions":
+            from janito.tools.permissions_parse import parse_permissions_string
+            from janito.tools.permissions import set_global_allowed_permissions
+            perms = parse_permissions_string(value)
+            global_config.file_set("tool_permissions", value)
+            set_global_allowed_permissions(perms)
+            print(f"Tool permissions set to '{value}' (parsed: {perms})")
+            return True
         print(
-            f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, azure_deployment_name, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url"
+            f"Error: Unknown config key '{key}'. Supported: provider, model, <provider>.model, max_tokens, base_url, azure_deployment_name, <provider>.max_tokens, <provider>.base_url, <provider>.<model>.max_tokens, <provider>.<model>.base_url, tool_permissions"
         )
         return True
     except Exception as e:

janito/cli/main_cli.py

@@ -14,6 +14,14 @@ from janito.cli.core.event_logger import (
 )
 
 definition = [
+    (
+        ["--profile"],
+        {
+            "metavar": "PROFILE",
+            "help": "Select the profile name for the system prompt (e.g. 'developer').",
+            "default": None,
+        },
+    ),
     (
         ["-W", "--workdir"],
         {
@@ -57,6 +65,20 @@ definition = [
             "help": "Enable execution/run tools (allows running code or shell tools from the CLI)",
         },
     ),
+    (
+        ["-r", "--read"],
+        {
+            "action": "store_true",
+            "help": "Enable tools that require read permissions",
+        },
+    ),
+    (
+        ["-w", "--write"],
+        {
+            "action": "store_true",
+            "help": "Enable tools that require write permissions",
+        },
+    ),
     (["--unset"], {"metavar": "KEY", "help": "Unset (remove) a config key"}),
     (["--version"], {"action": "version", "version": None}),
     (["--list-tools"], {"action": "store_true", "help": "List all registered tools"}),
@@ -85,7 +107,6 @@ definition = [
             "help": "Show the resolved system prompt for the main agent",
         },
     ),
-    (["-r", "--role"], {"metavar": "ROLE", "help": "Set the role for the agent"}),
     (["-p", "--provider"], {"metavar": "PROVIDER", "help": "Select the provider"}),
     (["-m", "--model"], {"metavar": "MODEL", "help": "Select the model"}),
     (
@@ -104,7 +125,7 @@ definition = [
         },
     ),
     (
-        ["-w", "--web"],
+        ["--web"],
         {
             "action": "store_true",
             "default": False,
@@ -112,11 +133,11 @@ definition = [
         },
     ),
     (
-        ["--termweb-port"],
+        ["---port"],
         {
             "type": int,
             "default": 8088,
-            "help": "Port for the termweb server (default: 8088)",
+            "help": "Port for the  server (default: 8088)",
         },
     ),
     (["--effort"],
@@ -150,10 +171,12 @@ MODIFIER_KEYS = [
     "verbose",
     "raw",
     "web",
-    "termweb_port",
+    "_port",
     "verbose_api",
     "verbose_tools",
     "exec",
+    "read",
+    "write",
 ]
 SETTER_KEYS = ["set", "set_provider", "set_api_key", "unset"]
 GETTER_KEYS = ["show_config", "list_providers", "list_models", "list_tools"]
@@ -177,6 +200,17 @@ class JanitoCLI:
         self._define_args()
         self.args = self.parser.parse_args()
         self._set_all_arg_defaults()
+        # Support reading prompt from stdin if no user_prompt is given
+        import sys
+        if not sys.stdin.isatty():
+            stdin_input = sys.stdin.read().strip()
+            if stdin_input:
+                if self.args.user_prompt and len(self.args.user_prompt) > 0:
+                    # Prefix the prompt argument to the stdin input
+                    combined = ' '.join(self.args.user_prompt) + ' ' + stdin_input
+                    self.args.user_prompt = [combined]
+                else:
+                    self.args.user_prompt = [stdin_input]
         from janito.cli.rich_terminal_reporter import RichTerminalReporter
 
         self.rich_reporter = RichTerminalReporter(raw_mode=self.args.raw)
@@ -212,9 +246,6 @@ class JanitoCLI:
             if getattr(self.args, k, None) is not None
         }
 
-    def exec_enabled(self):
-        return getattr(self.args, "exec", False)
-
     def classify(self):
         if any(getattr(self.args, k, None) for k in SETTER_KEYS):
             return RunMode.SET
@@ -268,8 +299,7 @@ class JanitoCLI:
                 llm_driver_config,
                 agent_role,
                 verbose_tools=self.args.verbose_tools,
-                exec_enabled=self.exec_enabled(),
-            )
+                            )
         elif run_mode == RunMode.GET:
             handle_getter(self.args)
 

janito/cli/prompt_core.py

@@ -3,7 +3,7 @@ Core PromptHandler: Handles prompt submission and response formatting for janito
 """
 
 import time
-from janito.version import __version__ as VERSION
+from janito import __version__ as VERSION
 from janito.performance_collector import PerformanceCollector
 from rich.status import Status
 from rich.console import Console
@@ -210,7 +210,23 @@ class PromptHandler:
                 on_event(final_event)
                 global_event_bus.publish(final_event)
         except KeyboardInterrupt:
-            self.console.print("[red]Request interrupted.[red]")
+            # Capture user interrupt / cancellation
+            self.console.print("[red]Interrupted by the user.[/red]")
+            try:
+                from janito.driver_events import RequestFinished, RequestStatus
+                # Record a synthetic "cancelled" final event so that downstream
+                # handlers (e.g. single_shot_mode.handler._post_prompt_actions)
+                # can reliably detect that the prompt was interrupted by the
+                # user and avoid showing misleading messages such as
+                # "No output produced by the model.".
+                if hasattr(self, "agent") and self.agent is not None:
+                    self.agent.last_event = RequestFinished(
+                        status=RequestStatus.CANCELLED,
+                        reason="Interrupted by the user",
+                    )
+            except Exception:
+                # Do not fail on cleanup – this hook is best-effort only.
+                pass
 
     def _print_verbose_debug(self, message):
         if hasattr(self.args, "verbose_agent") and self.args.verbose_agent: