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

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,
+    
+    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,
+        
+        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/rich_terminal_reporter.py

@@ -10,6 +10,8 @@ from janito.event_bus.bus import event_bus
 from janito.llm import message_parts
 
 
+import sys
+
 class RichTerminalReporter(EventHandlerBase):
     """
     Handles UI rendering for janito events using Rich.
@@ -63,8 +65,15 @@ class RichTerminalReporter(EventHandlerBase):
                 self.console.print(Markdown(part.content))
                 self.console.file.flush()
 
+    def delete_current_line(self):
+        """
+        Clears the entire current line in the terminal and returns the cursor to column 1.
+        """
+        sys.stdout.write('\033[2K\r')
+        sys.stdout.flush()
+
     def on_RequestFinished(self, event):
-        self.console.print("")  # Print end of line after waiting message
+        self.delete_current_line()
         self._waiting_printed = False
         response = getattr(event, "response", None)
         error = getattr(event, "error", None)
@@ -99,14 +108,14 @@ class RichTerminalReporter(EventHandlerBase):
         if not msg or not subtype:
             return
         if subtype == ReportSubtype.ACTION_INFO:
-            if getattr(event, "action", None) in (
+            # Use orange for modification actions, cyan otherwise
+            modification_actions = (
                 getattr(ReportAction, "UPDATE", None),
                 getattr(ReportAction, "WRITE", None),
                 getattr(ReportAction, "DELETE", None),
-            ):
-                self.console.print(f"[magenta]{msg}[/magenta]", end="")
-            else:
-                self.console.print(msg, end="")
+            )
+            style = "orange1" if getattr(event, "action", None) in modification_actions else "cyan"
+            self.console.print(Text(msg, style=style), end="")
             self.console.file.flush()
         elif subtype in (
             ReportSubtype.SUCCESS,
@@ -115,6 +124,12 @@ class RichTerminalReporter(EventHandlerBase):
         ):
             self.console.print(msg)
             self.console.file.flush()
+        elif subtype == ReportSubtype.STDOUT:
+            self.console.print(Text(msg, style="on dark_green"))
+            self.console.file.flush()
+        elif subtype == ReportSubtype.STDERR:
+            self.console.print(Text(msg, style="on red"))
+            self.console.file.flush()
         else:
             self.console.print(msg)
             self.console.file.flush()

janito/cli/single_shot_mode/handler.py

@@ -2,48 +2,31 @@
 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,  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,
-        )
-        # 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
+            
+            allowed_permissions=allowed_permissions,
+            profile=getattr(args, "profile", None),
         )
-        self.generic_handler.agent = self.agent
 
     def handle(self) -> None:
         import traceback
@@ -58,13 +41,18 @@ class PromptHandler:
             shared_console.print(
                 "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
             )
+        import time
         try:
+            start_time = time.time()
             self.generic_handler.handle_prompt(
                 sanitized,
                 args=self.args,
                 print_header=True,
                 raw=getattr(self.args, "raw", False),
             )
+            end_time = time.time()
+            elapsed = end_time - start_time
+            self._post_prompt_actions(elapsed=elapsed)
             if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
                 print("[debug] handle_prompt() completed without exception.")
         except Exception as e:
@@ -72,59 +60,18 @@ class PromptHandler:
                 f"[error] Exception occurred in handle_prompt: {type(e).__name__}: {e}"
             )
             traceback.print_exc()
-        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]")
+    def _post_prompt_actions(self, elapsed=None):
+        # Align with chat mode: only print token usage summary
+        import sys
+        from janito.formatting_token import print_token_message_summary
+        from janito.perf_singleton import performance_collector
+        usage = performance_collector.get_last_request_usage()
+        # If running in stdin mode, do not print token usage
+        if sys.stdin.isatty():
+            print_token_message_summary(shared_console, msg_count=1, usage=usage, elapsed=elapsed)
         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_manager.py

@@ -1,112 +1,125 @@
-import json
-from pathlib import Path
-from threading import Lock
-
-
-class ConfigManager:
-    """
-    Unified configuration manager supporting:
-      - Defaults
-      - File-based configuration
-      - Runtime overrides (e.g., CLI args)
-    """
-
-    _instance = None
-    _lock = Lock()
-
-    def __new__(cls, *args, **kwargs):
-        with cls._lock:
-            if not cls._instance:
-                cls._instance = super(ConfigManager, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
-        # Lazy single-init
-        if hasattr(self, "_initialized") and self._initialized:
-            return
-        self._initialized = True
-
-        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
-        self.defaults = dict(defaults) if defaults else {}
-        self.file_config = {}
-        self.runtime_overrides = dict(runtime_overrides) if runtime_overrides else {}
-        self._load_file_config()
-
-    def _load_file_config(self):
-        if self.config_path.exists():
-            with open(self.config_path, "r", encoding="utf-8") as f:
-                try:
-                    self.file_config = json.load(f)
-                except Exception:
-                    self.file_config = {}
-        else:
-            self.file_config = {}
-
-    def save(self):
-        self.config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def get(self, key, default=None):
-        # Precedence: runtime_overrides > file_config > defaults
-        for layer in (self.runtime_overrides, self.file_config, self.defaults):
-            if key in layer and layer[key] is not None:
-                return layer[key]
-        return default
-
-    def runtime_set(self, key, value):
-        self.runtime_overrides[key] = value
-
-    def file_set(self, key, value):
-        # Always reload, update, and persist
-        self._load_file_config()
-        self.file_config[key] = value
-        with open(self.config_path, "w", encoding="utf-8") as f:
-            json.dump(self.file_config, f, indent=2)
-            f.write("\n")
-
-    def all(self, layered=False):
-        merged = dict(self.defaults)
-        merged.update(self.file_config)
-        merged.update(self.runtime_overrides)
-        if layered:
-            # Only file+runtime, i.e., what is saved to disk
-            d = dict(self.file_config)
-            d.update(self.runtime_overrides)
-            return d
-        return merged
-
-    # Namespaced provider/model config
-    def get_provider_config(self, provider, default=None):
-        providers = self.file_config.get("providers") or {}
-        return providers.get(provider) or (default or {})
-
-    def set_provider_config(self, provider, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        self.file_config["providers"][provider][key] = value
-
-    def get_provider_model_config(self, provider, model, default=None):
-        return (
-            self.file_config.get("providers")
-            or {}.get(provider, {}).get("models", {}).get(model)
-            or (default or {})
-        )
-
-    def set_provider_model_config(self, provider, model, key, value):
-        if "providers" not in self.file_config:
-            self.file_config["providers"] = {}
-        if provider not in self.file_config["providers"]:
-            self.file_config["providers"][provider] = {}
-        if "models" not in self.file_config["providers"][provider]:
-            self.file_config["providers"][provider]["models"] = {}
-        if model not in self.file_config["providers"][provider]["models"]:
-            self.file_config["providers"][provider]["models"][model] = {}
-        self.file_config["providers"][provider]["models"][model][key] = value
-
-    # Support loading runtime overrides after init (e.g. after parsing CLI args)
-    def apply_runtime_overrides(self, overrides_dict):
-        self.runtime_overrides.update(overrides_dict)
+import json
+from pathlib import Path
+from threading import Lock
+
+
+class ConfigManager:
+    """
+    Unified configuration manager supporting:
+      - Defaults
+      - File-based configuration
+      - Runtime overrides (e.g., CLI args)
+    """
+
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls, *args, **kwargs):
+        with cls._lock:
+            if not cls._instance:
+                cls._instance = super(ConfigManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path=None, defaults=None, runtime_overrides=None):
+        # Lazy single-init
+        if hasattr(self, "_initialized") and self._initialized:
+            return
+        self._initialized = True
+
+        self.config_path = Path(config_path or Path.home() / ".janito" / "config.json")
+        self.defaults = dict(defaults) if defaults else {}
+        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():
+            with open(self.config_path, "r", encoding="utf-8") as f:
+                try:
+                    self.file_config = json.load(f)
+                except Exception:
+                    self.file_config = {}
+        else:
+            self.file_config = {}
+
+    def save(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def get(self, key, default=None):
+        # Precedence: runtime_overrides > file_config > defaults
+        for layer in (self.runtime_overrides, self.file_config, self.defaults):
+            if key in layer and layer[key] is not None:
+                return layer[key]
+        return default
+
+    def runtime_set(self, key, value):
+        self.runtime_overrides[key] = value
+
+    def file_set(self, key, value):
+        # Always reload, update, and persist
+        self._load_file_config()
+        self.file_config[key] = value
+        with open(self.config_path, "w", encoding="utf-8") as f:
+            json.dump(self.file_config, f, indent=2)
+            f.write("\n")
+
+    def all(self, layered=False):
+        merged = dict(self.defaults)
+        merged.update(self.file_config)
+        merged.update(self.runtime_overrides)
+        if layered:
+            # Only file+runtime, i.e., what is saved to disk
+            d = dict(self.file_config)
+            d.update(self.runtime_overrides)
+            return d
+        return merged
+
+    # Namespaced provider/model config
+    def get_provider_config(self, provider, default=None):
+        providers = self.file_config.get("providers") or {}
+        return providers.get(provider) or (default or {})
+
+    def set_provider_config(self, provider, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        self.file_config["providers"][provider][key] = value
+
+    def get_provider_model_config(self, provider, model, default=None):
+        return (
+            self.file_config.get("providers")
+            or {}.get(provider, {}).get("models", {}).get(model)
+            or (default or {})
+        )
+
+    def set_provider_model_config(self, provider, model, key, value):
+        if "providers" not in self.file_config:
+            self.file_config["providers"] = {}
+        if provider not in self.file_config["providers"]:
+            self.file_config["providers"][provider] = {}
+        if "models" not in self.file_config["providers"][provider]:
+            self.file_config["providers"][provider]["models"] = {}
+        if model not in self.file_config["providers"][provider]["models"]:
+            self.file_config["providers"][provider]["models"][model] = {}
+        self.file_config["providers"][provider]["models"][model][key] = value
+
+    # Support loading runtime overrides after init (e.g. after parsing CLI args)
+    def apply_runtime_overrides(self, overrides_dict):
+        self.runtime_overrides.update(overrides_dict)

janito/drivers/driver_registry.py

@@ -8,13 +8,11 @@ from typing import Dict, Type
 # --- Import driver classes ---
 from janito.drivers.anthropic.driver import AnthropicModelDriver
 from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
-from janito.drivers.mistralai.driver import MistralAIModelDriver
 from janito.drivers.openai.driver import OpenAIModelDriver
 
 _DRIVER_REGISTRY: Dict[str, Type] = {
     "AnthropicModelDriver": AnthropicModelDriver,
     "AzureOpenAIModelDriver": AzureOpenAIModelDriver,
-    "MistralAIModelDriver": MistralAIModelDriver,
     "OpenAIModelDriver": OpenAIModelDriver,
 }
 

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

janito/formatting_token.py

@@ -25,9 +25,9 @@ def format_tokens(n, tag=None, use_rich=False):
     return val
 
 
-def format_token_message_summary(msg_count, usage, width=96, use_rich=False):
+def format_token_message_summary(msg_count, usage, width=96, use_rich=False, elapsed=None):
     """
-    Returns a string (rich or pt markup) summarizing message count and last token usage.
+    Returns a string (rich or pt markup) summarizing message count, last token usage, and elapsed time.
     """
     left = f" Messages: {'[' if use_rich else '<'}msg_count{']' if use_rich else '>'}{msg_count}{'[/msg_count]' if use_rich else '</msg_count>'}"
     tokens_part = ""
@@ -40,15 +40,16 @@ def format_token_message_summary(msg_count, usage, width=96, use_rich=False):
             f"Completion: {format_tokens(completion_tokens, 'tokens_out', use_rich)}, "
             f"Total: {format_tokens(total_tokens, 'tokens_total', use_rich)}"
         )
-    return f"{left}{tokens_part}"
+    elapsed_part = f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
+    return f"{left}{tokens_part}{elapsed_part}"
 
 
-def print_token_message_summary(console, msg_count=None, usage=None, width=96):
-    """Prints the summary using rich markup, using defaults from perf_singleton if not given."""
+def print_token_message_summary(console, msg_count=None, usage=None, width=96, elapsed=None):
+    """Prints the summary using rich markup, using defaults from perf_singleton if not given. Optionally includes elapsed time."""
     if usage is None:
         usage = performance_collector.get_last_request_usage()
     if msg_count is None:
         msg_count = performance_collector.get_total_turns() or 0
-    line = format_token_message_summary(msg_count, usage, width, use_rich=True)
+    line = format_token_message_summary(msg_count, usage, width, use_rich=True, elapsed=elapsed)
     if line.strip():
         console.print(Rule(line))

janito/i18n/pt.py

@@ -3,7 +3,6 @@ translations = {
     "36107ed78ab25f6fb12ad8ce13018cd1ce6735d1": "Iniciando servidor web...",
     "70a0d194687568a47aa617fd85036ace1e69a982": "Deseja realmente sair? (s/n): ",
     "5c9ebcbbd7632ecb328bd52958b17158afaa32c6": "F12 = Ação Rápida (segue a ação recomendada)",
-    "e4034394acca752c021b2ab50f60da8273e3c314": "TermWeb iniciado... Disponível em http://localhost:{selected_port}",
     "fe21121e2934234b68d19b2757532117d440c1e3": "Chave de API não encontrada. Por favor, configure 'api_key' no seu arquivo de configuração.",
     "c9e3759b1756eba35b381ce2b72cd659e132b01f": "Olá, {name}!",
     "ca1fee2f55baabdc2e4b0e9529c89ee024e62079": "Nenhum prompt fornecido nas mensagens",

janito/llm/README.md

@@ -0,0 +1,23 @@
+# janito.llm Package
+
+This directory contains generic, provider-agnostic classes and methods for working with Large Language Models (LLMs) in the `janito` framework. Its purpose is to provide base abstractions that can be extended by provider-specific implementations.
+
+## Scope and Contents
+
+- **driver.py**
+  - Contains `LLMDriver`, an abstract base class defining the core methods for LLM drivers. Subclasses should implement provider/model-specific logic, while benefiting from consistent streaming and event interfaces.
+- **provider.py**
+  - Contains `LLMProvider`, an abstract base class for LLM API providers. This outlines the required interface for integrating new providers and retrieving model info or driver classes.
+
+## Usage
+- Extend these base classes when adding new drivers or providers.
+- Do not include provider-specific logic here; only generic mechanisms, patterns, or utilities applicable to any LLM integration belong in this package.
+
+## Example
+```python
+from janito.llm.driver import LLMDriver
+from janito.llm.provider import LLMProvider
+```
+
+---
+This README clarifies the intention of the `llm` package as the generic/static contract for LLM drivers and providers.