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

janito/cli/cli_commands/show_config.py

@@ -1,51 +1,51 @@
-from rich.console import Console
-from rich.pretty import Pretty
-
-from janito.config import config
-from janito.cli.config import CONFIG_OPTIONS
-
-
-def resolve_effective_model(provider_name):
-    # Try provider-specific model, then global model, then provider default
-    provider_cfg = config.get_provider_config(provider_name)
-    model = provider_cfg.get("model") if provider_cfg else None
-    if not model:
-        model = config.get("model")
-    if not model:
-        try:
-            from janito.provider_registry import ProviderRegistry
-
-            provider_class = ProviderRegistry().get_provider(provider_name)
-            model = getattr(provider_class, "DEFAULT_MODEL", None)
-        except Exception:
-            model = None
-    return model
-
-
-def handle_show_config(args):
-    console = Console()
-    provider = config.get("provider")
-    model = config.get("model")
-    # Show all providers with their effective model
-    from janito.provider_registry import ProviderRegistry
-
-    provider_names = []
-    try:
-        provider_names = ProviderRegistry()._get_provider_names()
-    except Exception:
-        pass
-    console.print("[bold green]Current configuration:[/bold green]")
-    console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
-    if model is not None:
-        console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
-    if provider_names:
-        console.print("[bold cyan]Provider specific default models:[/bold cyan]")
-        for pname in provider_names:
-            eff_model = resolve_effective_model(pname)
-            prov_cfg = config.get_provider_config(pname)
-            prov_model = prov_cfg.get("model") if prov_cfg else None
-            extra = f" (override)" if prov_model else ""
-            sel = "[default]" if pname == provider else ""
-            console.print(
-                f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
-            )
+from rich.console import Console
+from rich.pretty import Pretty
+
+from janito.config import config
+from janito.cli.config import CONFIG_OPTIONS
+
+
+def resolve_effective_model(provider_name):
+    # Try provider-specific model, then global model, then provider default
+    provider_cfg = config.get_provider_config(provider_name)
+    model = provider_cfg.get("model") if provider_cfg else None
+    if not model:
+        model = config.get("model")
+    if not model:
+        try:
+            from janito.provider_registry import ProviderRegistry
+
+            provider_class = ProviderRegistry().get_provider(provider_name)
+            model = getattr(provider_class, "DEFAULT_MODEL", None)
+        except Exception:
+            model = None
+    return model
+
+
+def handle_show_config(args):
+    console = Console()
+    provider = config.get("provider")
+    model = config.get("model")
+    # Show all providers with their effective model
+    from janito.provider_registry import ProviderRegistry
+
+    provider_names = []
+    try:
+        provider_names = ProviderRegistry()._get_provider_names()
+    except Exception:
+        pass
+    console.print("[bold green]Current configuration:[/bold green]")
+    console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
+    if model is not None:
+        console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
+    if provider_names:
+        console.print("[bold cyan]Provider specific default models:[/bold cyan]")
+        for pname in provider_names:
+            eff_model = resolve_effective_model(pname)
+            prov_cfg = config.get_provider_config(pname)
+            prov_model = prov_cfg.get("model") if prov_cfg else None
+            extra = f" (override)" if prov_model else ""
+            sel = "[default]" if pname == provider else ""
+            console.print(
+                f"  [bold]{pname}[/bold]{' '+sel if sel else ''}: model = [magenta]{eff_model}[/magenta]{extra}"
+            )

janito/cli/cli_commands/show_system_prompt.py

@@ -1,62 +1,105 @@
-"""
-CLI Command: Show the resolved system prompt for the main agent (single-shot mode)
-"""
-
-from janito.cli.core.runner import prepare_llm_driver_config
-from janito.platform_discovery import PlatformDiscovery
-from pathlib import Path
-from jinja2 import Template
-import importlib.resources
-
-
-def handle_show_system_prompt(args):
-    # Collect modifiers as in JanitoCLI
-    from janito.cli.main_cli import MODIFIER_KEYS
-
-    modifiers = {
-        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
-    }
-    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
-    if provider is None or llm_driver_config is None:
-        print("Error: Could not resolve provider or LLM driver config.")
-        return
-
-    # 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()
-
-    # 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"
-    template_content = None
-    if 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"
-            ).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
-
-    template = Template(template_content)
-    system_prompt = template.render(**context)
-
-    print("\n--- System Prompt (resolved) ---\n")
-    print(system_prompt)
-    print("\n-------------------------------\n")
-    if agent_role:
-        print(f"[Role: {agent_role}]")
+"""
+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
+from janito.platform_discovery import PlatformDiscovery
+from pathlib import Path
+from jinja2 import Template
+import importlib.resources
+
+
+def handle_show_system_prompt(args):
+    # Collect modifiers as in JanitoCLI
+    from janito.cli.main_cli import MODIFIER_KEYS
+
+    modifiers = {
+        k: getattr(args, k) for k in MODIFIER_KEYS if getattr(args, k, None) is not None
+    }
+    provider, llm_driver_config, agent_role = prepare_llm_driver_config(args, modifiers)
+    if provider is None or llm_driver_config is None:
+        print("Error: Could not resolve provider or LLM driver config.")
+        return
+
+    # Prepare context for Jinja2 rendering
+    context = {}
+    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"
+    )
+    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 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(
+                template_filename
+            ).open("r", encoding="utf-8") as file:
+                template_content = file.read()
+        except (FileNotFoundError, ModuleNotFoundError, AttributeError):
+            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(f"\n--- System Prompt (resolved, profile: {getattr(args, 'profile', 'main')}) ---\n")
+    print(system_prompt)
+    print("\n-------------------------------\n")
+    if agent_role:
+        print(f"[Role: {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/__init__.py

@@ -1,4 +1,4 @@
-"""
-Core logic, handler classes, and utilities for the main Janito CLI orchestration and sub-command processing.
-Contains modules for setters, getters, event logger, and runner pipelines.
-"""
+"""
+Core logic, handler classes, and utilities for the main Janito CLI orchestration and sub-command processing.
+Contains modules for setters, getters, event logger, and runner pipelines.
+"""

janito/cli/core/event_logger.py

@@ -1,59 +1,59 @@
-"""Stub implementation of EventLogger for the CLI event logging system."""
-
-
-class EventLogger:
-    def __init__(self, debug=False):
-        self.debug = debug
-
-    def subscribe(self, event_name, callback):
-        if self.debug:
-            pass  # Add debug subscribe output if needed
-        # No real subscription logic
-
-    def submit(self, event_name, payload=None):
-        if self.debug:
-            pass  # Add debug submit output if needed
-        # No real submission logic
-
-
-def setup_event_logger(args):
-    debug = getattr(args, "event_debug", False)
-    event_logger = EventLogger(debug=debug)
-    print("[EventLog] Event logger is now active (stub implementation)")
-    return event_logger
-
-
-def setup_event_logger_if_needed(args):
-    if getattr(args, "event_log", False):
-        print("[EventLog] Setting up event logger with system bus...")
-        event_logger = setup_event_logger(args)
-        from janito.event_bus import event_bus
-
-        def event_logger_handler(event):
-            from janito.cli.console import shared_console
-            from rich.pretty import Pretty
-            from datetime import datetime
-
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            shared_console.print(
-                f"[EventLog] [dim]{timestamp}[/] [bold green]{event.__class__.__name__}[/] | [cyan]{getattr(event, 'category', '')}[/]"
-            )
-            shared_console.print(Pretty(event, expand_all=True))
-            shared_console.file.flush()
-
-        from janito.event_bus.event import Event
-
-        event_bus.subscribe(Event, event_logger_handler)
-
-
-def inject_debug_event_bus_if_needed(args):
-    if getattr(args, "event_debug", False):
-        from janito.event_bus import event_bus
-
-        orig_publish = event_bus.publish
-
-        def debug_publish(event):
-            # You can enrich here if needed
-            return orig_publish(event)
-
-        event_bus.publish = debug_publish
+"""Stub implementation of EventLogger for the CLI event logging system."""
+
+
+class EventLogger:
+    def __init__(self, debug=False):
+        self.debug = debug
+
+    def subscribe(self, event_name, callback):
+        if self.debug:
+            pass  # Add debug subscribe output if needed
+        # No real subscription logic
+
+    def submit(self, event_name, payload=None):
+        if self.debug:
+            pass  # Add debug submit output if needed
+        # No real submission logic
+
+
+def setup_event_logger(args):
+    debug = getattr(args, "event_debug", False)
+    event_logger = EventLogger(debug=debug)
+    print("[EventLog] Event logger is now active (stub implementation)")
+    return event_logger
+
+
+def setup_event_logger_if_needed(args):
+    if getattr(args, "event_log", False):
+        print("[EventLog] Setting up event logger with system bus...")
+        event_logger = setup_event_logger(args)
+        from janito.event_bus import event_bus
+
+        def event_logger_handler(event):
+            from janito.cli.console import shared_console
+            from rich.pretty import Pretty
+            from datetime import datetime
+
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            shared_console.print(
+                f"[EventLog] [dim]{timestamp}[/] [bold green]{event.__class__.__name__}[/] | [cyan]{getattr(event, 'category', '')}[/]"
+            )
+            shared_console.print(Pretty(event, expand_all=True))
+            shared_console.file.flush()
+
+        from janito.event_bus.event import Event
+
+        event_bus.subscribe(Event, event_logger_handler)
+
+
+def inject_debug_event_bus_if_needed(args):
+    if getattr(args, "event_debug", False):
+        from janito.event_bus import event_bus
+
+        orig_publish = event_bus.publish
+
+        def debug_publish(event):
+            # You can enrich here if needed
+            return orig_publish(event)
+
+        event_bus.publish = debug_publish

janito/cli/core/runner.py

@@ -92,7 +92,7 @@ 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
 
 
@@ -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 = exec_enabled
+    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,
+            exec_enabled=exec_enabled,
+            allowed_permissions=allowed_permissions,
         )
         handler.handle()
     else:
@@ -157,6 +163,7 @@ def handle_runner(args, provider, llm_driver_config, agent_role, verbose_tools=F
             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/core/unsetters.py

@@ -1,54 +1,54 @@
-from janito.config import config as global_config
-
-
-def handle_unset(args):
-    unset_arg = getattr(args, "unset", None)
-    if not unset_arg:
-        return False
-    key = unset_arg.strip().replace("-", "_")
-    if "." in key:
-        # Provider or model-specific keys
-        parts = key.split(".")
-        if len(parts) == 2:
-            provider, subkey = parts
-            current_val = (
-                global_config.file_config.get("providers", {})
-                .get(provider, {})
-                .get(subkey)
-            )
-            if current_val is not None:
-                del global_config.file_config["providers"][provider][subkey]
-                global_config.save()
-                print(f"{key}={current_val} was removed.")
-                return True
-        elif len(parts) == 3:
-            provider, model, subkey = parts
-            model_conf = (
-                global_config.file_config.get("providers", {})
-                .get(provider, {})
-                .get("models", {})
-                .get(model, {})
-            )
-            current_val = model_conf.get(subkey)
-            if current_val is not None:
-                del global_config.file_config["providers"][provider]["models"][model][
-                    subkey
-                ]
-                global_config.save()
-                print(f"{key}={current_val} was removed.")
-                return True
-    else:
-        current_val = global_config.file_config.get(key)
-        if current_val is not None:
-            del global_config.file_config[key]
-            global_config.save()
-            print(f"{key}={current_val} was removed.")
-            return True
-    if "=" in unset_arg:
-        provided_key = unset_arg.split("=")[0].strip()
-        print(
-            f"Error: --unset expected a key, not key=value. Did you mean: --unset {provided_key}?"
-        )
-    else:
-        print(f"Error: no value set for {key} (cannot remove)")
-    return True
+from janito.config import config as global_config
+
+
+def handle_unset(args):
+    unset_arg = getattr(args, "unset", None)
+    if not unset_arg:
+        return False
+    key = unset_arg.strip().replace("-", "_")
+    if "." in key:
+        # Provider or model-specific keys
+        parts = key.split(".")
+        if len(parts) == 2:
+            provider, subkey = parts
+            current_val = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get(subkey)
+            )
+            if current_val is not None:
+                del global_config.file_config["providers"][provider][subkey]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+        elif len(parts) == 3:
+            provider, model, subkey = parts
+            model_conf = (
+                global_config.file_config.get("providers", {})
+                .get(provider, {})
+                .get("models", {})
+                .get(model, {})
+            )
+            current_val = model_conf.get(subkey)
+            if current_val is not None:
+                del global_config.file_config["providers"][provider]["models"][model][
+                    subkey
+                ]
+                global_config.save()
+                print(f"{key}={current_val} was removed.")
+                return True
+    else:
+        current_val = global_config.file_config.get(key)
+        if current_val is not None:
+            del global_config.file_config[key]
+            global_config.save()
+            print(f"{key}={current_val} was removed.")
+            return True
+    if "=" in unset_arg:
+        provided_key = unset_arg.split("=")[0].strip()
+        print(
+            f"Error: --unset expected a key, not key=value. Did you mean: --unset {provided_key}?"
+        )
+    else:
+        print(f"Error: no value set for {key} (cannot remove)")
+    return True