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

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"]

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:

janito/cli/prompt_setup.py

@@ -0,0 +1,56 @@
+"""
+Shared utilities to set up an agent together with a GenericPromptHandler that
+both single–shot and chat modes can reuse.  Having one central place avoids the
+code duplication that previously existed in `chat_mode.session.ChatSession` and
+`single_shot_mode.handler.PromptHandler`.
+"""
+from __future__ import annotations
+
+from janito.agent.setup_agent import create_configured_agent
+from janito.cli.prompt_core import (
+    PromptHandler as GenericPromptHandler,
+)
+from typing import Any, Optional
+
+
+def setup_agent_and_prompt_handler(
+    *,
+    args: Any,
+    provider_instance: Any,
+    llm_driver_config: Any,
+    role: Optional[str] = None,
+    verbose_tools: bool = False,
+    verbose_agent: bool = False,
+    exec_enabled: bool = False,
+    allowed_permissions: Optional[list[str]] = None,
+    profile: Optional[str] = None,
+    profile_system_prompt: Optional[str] = None,
+    conversation_history: Any = None,
+):
+    """Create a configured *agent* as well as a *GenericPromptHandler* bound to
+    that agent and return them as a tuple.
+
+    This helper consolidates the repetitive boiler-plate that was scattered
+    across *single-shot* and *chat* modes – both of which need an agent plus a
+    prompt handler that points to that agent.
+    """
+    agent = create_configured_agent(
+        provider_instance=provider_instance,
+        llm_driver_config=llm_driver_config,
+        role=role,
+        verbose_tools=verbose_tools,
+        verbose_agent=verbose_agent,
+        exec_enabled=exec_enabled,
+        allowed_permissions=allowed_permissions,
+        profile=profile,
+        profile_system_prompt=profile_system_prompt,
+    )
+
+    prompt_handler = GenericPromptHandler(
+        args=args,
+        conversation_history=conversation_history,
+        provider_instance=provider_instance,
+    )
+    prompt_handler.agent = agent
+
+    return agent, prompt_handler

janito/cli/single_shot_mode/__init__.py

@@ -1,6 +1,6 @@
-# janito.cli.single_shot_mode package
-from .handler import PromptHandler
-
-__all__ = [
-    "PromptHandler",
-]
+# janito.cli.single_shot_mode package
+from .handler import PromptHandler
+
+__all__ = [
+    "PromptHandler",
+]

janito/cli/single_shot_mode/handler.py

@@ -2,48 +2,32 @@
 PromptHandler: Handles prompt submission and response formatting for janito CLI (one-shot prompt execution).
 """
 
-import time
-from janito.version import __version__ as VERSION
-from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
-from janito.cli.verbose_output import (
-    print_verbose_header,
-    print_performance,
-    handle_exception,
-)
+from __future__ import annotations
+
+from janito.cli.prompt_setup import setup_agent_and_prompt_handler
 import janito.tools  # Ensure all tools are registered
 from janito.cli.console import shared_console
 
 
 class PromptHandler:
-    def __init__(self, args, provider_instance, llm_driver_config, role=None, exec_enabled=False):
+    def __init__(self, args, provider_instance, llm_driver_config, role=None, exec_enabled=False, allowed_permissions=None):
         self.args = args
         self.provider_instance = provider_instance
         self.llm_driver_config = llm_driver_config
         self.role = role
         self.exec_enabled = exec_enabled
-        from janito.agent.setup_agent import create_configured_agent
-
-        # DEBUG: Print exec_enabled propagation
-        self.agent = create_configured_agent(
+        # Instantiate agent together with prompt handler using the shared helper
+        self.agent, self.generic_handler = setup_agent_and_prompt_handler(
+            args=args,
             provider_instance=provider_instance,
             llm_driver_config=llm_driver_config,
             role=role,
             verbose_tools=getattr(args, "verbose_tools", False),
             verbose_agent=getattr(args, "verbose_agent", False),
             exec_enabled=exec_enabled,
+            allowed_permissions=allowed_permissions,
+            profile=getattr(args, "profile", None),
         )
-        # Setup conversation/history if needed
-        # 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(exec_enabled)
-        except Exception as e:
-            shared_console.print(f"[yellow]Warning: Could not update execution tools dynamically in single-shot mode: {e}[/yellow]")
-        self.generic_handler = GenericPromptHandler(
-            args, [], provider_instance=provider_instance
-        )
-        self.generic_handler.agent = self.agent
 
     def handle(self) -> None:
         import traceback
@@ -75,56 +59,13 @@ class PromptHandler:
         self._post_prompt_actions()
 
     def _post_prompt_actions(self):
-        final_event = getattr(self.agent, "last_event", None)
-        if final_event is not None:
-            self._print_exit_reason_and_parts(final_event)
-            # --- BEGIN: Print token info in rich rule if --verbose is set ---
-            if hasattr(self.args, "verbose") and self.args.verbose:
-                from janito.perf_singleton import performance_collector
-
-                token_info = performance_collector.get_last_request_usage()
-                from rich.rule import Rule
-                from rich import print as rich_print
-                from janito.cli.utils import format_tokens
-
-                if token_info:
-                    if isinstance(token_info, dict):
-                        token_str = " | ".join(
-                            f"{k}: {format_tokens(v) if isinstance(v, int) else v}"
-                            for k, v in token_info.items()
-                        )
-                    else:
-                        token_str = str(token_info)
-                    rich_print(Rule(f"[bold cyan]Token Usage[/bold cyan] {token_str}"))
-                else:
-                    rich_print(Rule("[cyan]No token usage info available.[/cyan]"))
-        else:
-            shared_console.print("[yellow]No output produced by the model.[/yellow]")
+        # Align with chat mode: only print token usage summary
+        from janito.formatting_token import print_token_message_summary
+        from janito.perf_singleton import performance_collector
+        usage = performance_collector.get_last_request_usage()
+        print_token_message_summary(shared_console, msg_count=1, usage=usage)
         self._cleanup_driver_and_console()
 
-    def _print_exit_reason_and_parts(self, final_event):
-        exit_reason = (
-            getattr(final_event, "metadata", {}).get("exit_reason")
-            if hasattr(final_event, "metadata")
-            else None
-        )
-        if exit_reason:
-            print(f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]")
-        parts = getattr(final_event, "parts", None)
-        if not exit_reason:
-            if parts is None or len(parts) == 0:
-                shared_console.print(
-                    "[yellow]No output produced by the model.[/yellow]"
-                )
-            else:
-                if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
-                    print(
-                        "[yellow]No user-visible output. Model returned the following parts:"
-                    )
-                    for idx, part in enumerate(parts):
-                        print(
-                            f"  [part {idx}] type: {type(part).__name__} | content: {getattr(part, 'content', repr(part))}"
-                        )
 
     def _cleanup_driver_and_console(self):
         if hasattr(self.agent, "join_driver"):

janito/cli/verbose_output.py

@@ -6,7 +6,7 @@ from rich import print as rich_print
 from rich.align import Align
 from rich.panel import Panel
 from rich.text import Text
-from janito.version import __version__ as VERSION
+from janito import __version__ as VERSION
 from janito.cli.utils import format_tokens
 
 

janito/config.py

@@ -1,5 +1,5 @@
-# Shared Janito ConfigManager singleton
-from janito.config_manager import ConfigManager
-
-# Only one global instance! Used by CLI, provider_config, others:
-config = ConfigManager(config_path=None)
+# Shared Janito ConfigManager singleton
+from janito.config_manager import ConfigManager
+
+# Only one global instance! Used by CLI, provider_config, others:
+config = ConfigManager(config_path=None)

janito/config_manager.py

@@ -31,6 +31,19 @@ class ConfigManager:
         self.file_config = {}
         self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
         self._load_file_config()
+        self._apply_tool_permissions_on_startup()
+
+    def _apply_tool_permissions_on_startup(self):
+        # On startup, read tool_permissions from config and set global permissions
+        perm_str = self.file_config.get("tool_permissions")
+        if perm_str:
+            try:
+                from janito.tools.permissions_parse import parse_permissions_string
+                from janito.tools.permissions import set_global_allowed_permissions
+                perms = parse_permissions_string(perm_str)
+                set_global_allowed_permissions(perms)
+            except Exception as e:
+                print(f"Warning: Failed to apply tool_permissions from config: {e}")
 
     def _load_file_config(self):
         if self.config_path.exists():

janito/drivers/anthropic/driver.py

@@ -1,113 +1,113 @@
-from janito.llm.driver import LLMDriver
-from janito.llm.driver_config import LLMDriverConfig
-from janito.driver_events import (
-    GenerationStarted,
-    GenerationFinished,
-    RequestStarted,
-    RequestFinished,
-    ResponseReceived,
-)
-from janito.llm.message_parts import TextMessagePart
-import uuid
-import traceback
-import time
-
-# Safe import of anthropic SDK
-try:
-    import anthropic
-
-    DRIVER_AVAILABLE = True
-    DRIVER_UNAVAILABLE_REASON = None
-except ImportError:
-    DRIVER_AVAILABLE = False
-    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
-
-
-class AnthropicModelDriver(LLMDriver):
-    available = False
-    unavailable_reason = "AnthropicModelDriver is not implemented yet."
-
-    @classmethod
-    def is_available(cls):
-        return cls.available
-
-    """
-    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
-    """
-    required_config = ["api_key", "model"]
-
-    def __init__(self, tools_adapter=None):
-        raise ImportError(self.unavailable_reason)
-
-    def _create_client(self):
-        try:
-            import anthropic
-        except ImportError:
-            raise Exception(
-                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
-            )
-        return anthropic.Anthropic(api_key=self.api_key)
-
-    def _run_generation(
-        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
-    ):
-        request_id = str(uuid.uuid4())
-        client = self._create_client()
-        try:
-            prompt = ""
-            if isinstance(messages_or_prompt, str):
-                prompt = messages_or_prompt
-            elif isinstance(messages_or_prompt, list):
-                chat = []
-                for msg in messages_or_prompt:
-                    if msg.get("role") == "user":
-                        chat.append("Human: " + msg.get("content", ""))
-                    elif msg.get("role") == "assistant":
-                        chat.append("Assistant: " + msg.get("content", ""))
-                prompt = "\n".join(chat)
-            if system_prompt:
-                prompt = f"System: {system_prompt}\n{prompt}"
-
-            self.publish(
-                GenerationStarted,
-                request_id,
-                conversation_history=list(getattr(self, "_history", [])),
-            )
-            self.publish(RequestStarted, request_id, payload={})
-            start_time = time.time()
-            response = client.completions.create(
-                model=self.model_name,
-                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
-                prompt=prompt,
-                temperature=float(getattr(self.config, "default_temp", 0.7)),
-            )
-            duration = time.time() - start_time
-            content = response.completion if hasattr(response, "completion") else None
-            self.publish(
-                RequestFinished,
-                request_id,
-                response=content,
-                status=RequestStatus.SUCCESS,
-                usage={},
-            )
-            parts = []
-            if content:
-                parts.append(TextMessagePart(content=content))
-            self.publish(
-                ResponseReceived,
-                request_id=request_id,
-                parts=parts,
-                tool_results=[],
-                timestamp=time.time(),
-                metadata={"raw_response": response},
-            )
-            self.publish(GenerationFinished, request_id, total_turns=1)
-        except Exception as e:
-            self.publish(
-                RequestFinished,
-                request_id,
-                status=RequestStatus.ERROR,
-                error=str(e),
-                exception=e,
-                traceback=traceback.format_exc(),
-            )
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_config import LLMDriverConfig
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+)
+from janito.llm.message_parts import TextMessagePart
+import uuid
+import traceback
+import time
+
+# Safe import of anthropic SDK
+try:
+    import anthropic
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: anthropic (pip install anthropic)"
+
+
+class AnthropicModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "AnthropicModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    """
+    LLMDriver for Anthropic's Claude API (v3), using the anthropic SDK.
+    """
+    required_config = ["api_key", "model"]
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)
+
+    def _create_client(self):
+        try:
+            import anthropic
+        except ImportError:
+            raise Exception(
+                "The 'anthropic' Python SDK is required. Please install via `pip install anthropic`."
+            )
+        return anthropic.Anthropic(api_key=self.api_key)
+
+    def _run_generation(
+        self, messages_or_prompt, system_prompt=None, tools=None, **kwargs
+    ):
+        request_id = str(uuid.uuid4())
+        client = self._create_client()
+        try:
+            prompt = ""
+            if isinstance(messages_or_prompt, str):
+                prompt = messages_or_prompt
+            elif isinstance(messages_or_prompt, list):
+                chat = []
+                for msg in messages_or_prompt:
+                    if msg.get("role") == "user":
+                        chat.append("Human: " + msg.get("content", ""))
+                    elif msg.get("role") == "assistant":
+                        chat.append("Assistant: " + msg.get("content", ""))
+                prompt = "\n".join(chat)
+            if system_prompt:
+                prompt = f"System: {system_prompt}\n{prompt}"
+
+            self.publish(
+                GenerationStarted,
+                request_id,
+                conversation_history=list(getattr(self, "_history", [])),
+            )
+            self.publish(RequestStarted, request_id, payload={})
+            start_time = time.time()
+            response = client.completions.create(
+                model=self.model_name,
+                max_tokens_to_sample=int(getattr(self.config, "max_response", 1024)),
+                prompt=prompt,
+                temperature=float(getattr(self.config, "default_temp", 0.7)),
+            )
+            duration = time.time() - start_time
+            content = response.completion if hasattr(response, "completion") else None
+            self.publish(
+                RequestFinished,
+                request_id,
+                response=content,
+                status=RequestStatus.SUCCESS,
+                usage={},
+            )
+            parts = []
+            if content:
+                parts.append(TextMessagePart(content=content))
+            self.publish(
+                ResponseReceived,
+                request_id=request_id,
+                parts=parts,
+                tool_results=[],
+                timestamp=time.time(),
+                metadata={"raw_response": response},
+            )
+            self.publish(GenerationFinished, request_id, total_turns=1)
+        except Exception as e:
+            self.publish(
+                RequestFinished,
+                request_id,
+                status=RequestStatus.ERROR,
+                error=str(e),
+                exception=e,
+                traceback=traceback.format_exc(),
+            )

janito/drivers/openai/README.md

@@ -0,0 +1,20 @@
+# OpenAI Driver Debugging
+
+## HTTP Debugging via Environment Variable
+
+To debug HTTP requests and responses for the OpenAI driver, set the environment variable `OPENAI_DEBUG_HTTP=1` before running your application. This will print the full HTTP request and response bodies to the console for troubleshooting purposes.
+
+**Example (PowerShell):**
+
+```
+$env:OPENAI_DEBUG_HTTP=1
+python your_app.py
+```
+
+**Example (bash):**
+
+```
+OPENAI_DEBUG_HTTP=1 python your_app.py
+```
+
+This feature is implemented in `janito/drivers/openai/driver.py` and works by wrapping the OpenAI client HTTP transport with a debug logger when the environment variable is set.

janito/event_bus/event.py

@@ -1,6 +1,6 @@
 import attr
 from typing import ClassVar
-from datetime import datetime
+from datetime import datetime, timezone
 
 
 @attr.s(auto_attribs=True, kw_only=True)
@@ -12,4 +12,4 @@ class Event:
     """
 
     category: ClassVar[str] = "generic"
-    timestamp: datetime = attr.ib(factory=datetime.utcnow)
+    timestamp: datetime = attr.ib(factory=lambda: datetime.now(timezone.utc))