janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/cli/prompt_core.py

@@ -0,0 +1,230 @@
+"""
+Core PromptHandler: Handles prompt submission and response formatting for janito CLI (shared by single and chat modes).
+"""
+
+import time
+from janito.version import __version__ as VERSION
+from janito.performance_collector import PerformanceCollector
+from rich.status import Status
+from rich.console import Console
+from typing import Any, Optional, Callable
+from janito.driver_events import RequestStarted, RequestFinished, RequestStatus
+from janito.tools.tool_events import ToolCallError
+import threading
+from janito.cli.verbose_output import print_verbose_header
+from janito.event_bus import event_bus as global_event_bus
+
+
+class StatusRef:
+    def __init__(self):
+        self.status = None
+
+
+class PromptHandler:
+    args: Any
+    agent: Any
+    performance_collector: PerformanceCollector
+    console: Console
+    provider_instance: Any
+
+    def __init__(self, args: Any, conversation_history, provider_instance) -> None:
+        self.temperature = args.temperature if hasattr(args, "temperature") else None
+        """
+        Initialize PromptHandler.
+        :param args: CLI or programmatic arguments for provider/model selection, etc.
+        :param conversation_history: LLMConversationHistory object for multi-turn chat mode.
+        :param provider_instance: An initialized provider instance.
+        """
+        self.args = args
+        self.conversation_history = conversation_history
+        self.provider_instance = provider_instance
+        self.agent = None
+        from janito.perf_singleton import performance_collector
+
+        self.performance_collector = performance_collector
+        self.console = Console()
+
+    def _handle_inner_event(self, inner_event, on_event, status):
+        if on_event:
+            on_event(inner_event)
+        from janito.tools.tool_events import ToolCallFinished
+
+        # Print tool result if ToolCallFinished event is received
+        if isinstance(inner_event, ToolCallFinished):
+            # Print result if verbose_tools is enabled or always for user visibility
+            if hasattr(self.args, "verbose_tools") and self.args.verbose_tools:
+                self.console.print(
+                    f"[cyan][tools-adapter] Tool '{inner_event.tool_name}' result:[/cyan] {inner_event.result}"
+                )
+            else:
+                self.console.print(inner_event.result)
+            return None
+        if isinstance(inner_event, RequestFinished):
+            status.update("[bold green]Received response![bold green]")
+            return "break"
+        elif (
+            isinstance(inner_event, RequestFinished)
+            and getattr(inner_event, "status", None) == "error"
+        ):
+            error_msg = (
+                inner_event.error if hasattr(inner_event, "error") else "Unknown error"
+            )
+            if (
+                "Status 429" in error_msg
+                and "Service tier capacity exceeded for this model" in error_msg
+            ):
+                status.update(
+                    "[yellow]Service tier capacity exceeded, retrying...[yellow]"
+                )
+                return "break"
+            status.update(f"[bold red]Error: {error_msg}[bold red]")
+            self.console.print(f"[red]Error: {error_msg}[red]")
+            return "break"
+        elif isinstance(inner_event, ToolCallError):
+            error_msg = (
+                inner_event.error
+                if hasattr(inner_event, "error")
+                else "Unknown tool error"
+            )
+            tool_name = (
+                inner_event.tool_name
+                if hasattr(inner_event, "tool_name")
+                else "unknown"
+            )
+            status.update(
+                f"[bold red]Tool Error in '{tool_name}': {error_msg}[bold red]"
+            )
+            self.console.print(f"[red]Tool Error in '{tool_name}': {error_msg}[red]")
+            return "break"
+        elif isinstance(inner_event, RequestFinished) and getattr(
+            inner_event, "status", None
+        ) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
+            details = getattr(inner_event, "details", None) or {}
+            block_reason = details.get("block_reason")
+            block_msg = details.get("block_reason_message")
+            msg = details.get(
+                "message", "LLM returned an empty or incomplete response."
+            )
+            driver_name = getattr(inner_event, "driver_name", "unknown driver")
+            if block_reason or block_msg:
+                status.update(
+                    f"[bold yellow]Blocked by driver: {driver_name} | {block_reason or ''} {block_msg or ''}[bold yellow]"
+                )
+                self.console.print(
+                    f"[yellow]Blocked by driver: {driver_name} (empty response): {block_reason or ''}\n{block_msg or ''}[/yellow]"
+                )
+            else:
+                status.update(
+                    f"[yellow]LLM produced no output for this request (driver: {driver_name}).[/yellow]"
+                )
+                self.console.print(
+                    f"[yellow]Warning: {msg} (driver: {driver_name})[/yellow]"
+                )
+            return "break"
+        # Report unknown event types
+        event_type = type(inner_event).__name__
+        self.console.print(
+            f"[yellow]Warning: Unknown event type encountered: {event_type}[yellow]"
+        )
+        return None
+
+    def _process_event_iter(self, event_iter, on_event):
+        for event in event_iter:
+            # Handle exceptions from generation thread
+            if isinstance(event, dict) and event.get("type") == "exception":
+                self.console.print("[red]Exception in generation thread:[red]")
+                self.console.print(event.get("traceback", "No traceback available"))
+                break
+            if on_event:
+                on_event(event)
+            if isinstance(event, RequestStarted):
+                pass  # No change needed for started event
+            elif isinstance(event, RequestFinished) and getattr(
+                event, "status", None
+            ) in ("error", "cancelled"):
+                # Handle error/cancelled as needed
+                for inner_event in event_iter:
+                    result = self._handle_inner_event(inner_event, on_event, None)
+                    if result == "break":
+                        break
+                # After exiting, continue with next events (if any)
+            # Handle other event types outside the spinner if needed
+            elif isinstance(event, RequestFinished) and getattr(
+                event, "status", None
+            ) in (RequestStatus.EMPTY_RESPONSE, RequestStatus.TIMEOUT):
+                details = getattr(event, "details", None) or {}
+                block_reason = details.get("block_reason")
+                block_msg = details.get("block_reason_message")
+                msg = details.get(
+                    "message", "LLM returned an empty or incomplete response."
+                )
+                driver_name = getattr(event, "driver_name", "unknown driver")
+                if block_reason or block_msg:
+                    self.console.print(
+                        f"[yellow]Blocked by driver: {driver_name} (empty response): {block_reason or ''}\n{block_msg or ''}[/yellow]"
+                    )
+                else:
+                    self.console.print(
+                        f"[yellow]Warning: {msg} (driver: {driver_name})[/yellow]"
+                    )
+            else:
+                pass
+
+    def handle_prompt(
+        self, user_prompt, args=None, print_header=True, raw=False, on_event=None
+    ):
+        # args defaults to self.args for compatibility in interactive mode
+        args = (
+            args if args is not None else self.args if hasattr(self, "args") else None
+        )
+        # Join/cleanup prompt
+        if isinstance(user_prompt, list):
+            user_prompt = " ".join(user_prompt).strip()
+        else:
+            user_prompt = str(user_prompt).strip() if user_prompt is not None else ""
+        if not user_prompt:
+            raise ValueError("No user prompt was provided!")
+        if print_header and hasattr(self, "agent") and args is not None:
+            print_verbose_header(self.agent, args)
+        self.run_prompt(user_prompt, raw=raw, on_event=on_event)
+
+    def run_prompt(
+        self, user_prompt: str, raw: bool = False, on_event: Optional[Callable] = None
+    ) -> None:
+        """
+        Handles a single prompt, using the blocking event-driven chat interface.
+        Optionally takes an on_event callback for custom event handling.
+        """
+        try:
+            self._print_verbose_debug("Calling agent.chat()...")
+            final_event = self.agent.chat(prompt=user_prompt)
+            if hasattr(self.agent, "set_latest_event"):
+                self.agent.set_latest_event(final_event)
+            self.agent.last_event = final_event
+            self._print_verbose_debug(f"agent.chat() returned: {final_event}")
+            self._print_verbose_final_event(final_event)
+            if on_event and final_event is not None:
+                on_event(final_event)
+                global_event_bus.publish(final_event)
+        except KeyboardInterrupt:
+            self.console.print("[red]Request interrupted.[red]")
+
+    def _print_verbose_debug(self, message):
+        if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
+            print(f"[prompt_core][DEBUG] {message}")
+
+    def _print_verbose_final_event(self, final_event):
+        if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
+            print("[prompt_core][DEBUG] Received final_event from agent.chat:")
+            print(f"  [prompt_core][DEBUG] type={type(final_event)}")
+            print(f"  [prompt_core][DEBUG] content={final_event}")
+
+    def run_prompts(
+        self, prompts: list, raw: bool = False, on_event: Optional[Callable] = None
+    ) -> None:
+        """
+        Handles multiple prompts in sequence, collecting performance data for each.
+        """
+        for prompt in prompts:
+            self.run_prompt(prompt, raw=raw, on_event=on_event)
+        # No return value

janito/cli/prompt_handler.py

@@ -0,0 +1,6 @@
+"""
+Generic PromptHandler: Handles prompt submission and response formatting for janito CLI.
+Supports both one-shot and multi-prompt scenarios.
+"""
+
+from janito.cli.prompt_core import PromptHandler, StatusRef

janito/cli/rich_terminal_reporter.py

@@ -0,0 +1,101 @@
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.pretty import Pretty
+from rich.panel import Panel
+from rich.text import Text
+from janito.event_bus.handler import EventHandlerBase
+import janito.driver_events as driver_events
+from janito.report_events import ReportSubtype, ReportAction
+from janito.event_bus.bus import event_bus
+from janito.llm import message_parts
+
+
+class RichTerminalReporter(EventHandlerBase):
+    """
+    Handles UI rendering for janito events using Rich.
+
+    - For ResponseReceived events, iterates over the 'parts' field and displays each part appropriately:
+        - TextMessagePart: rendered as Markdown (uses 'content' field)
+        - Other MessageParts: displayed using Pretty or a suitable Rich representation
+    - For RequestFinished events, output is printed only if raw mode is enabled (using Pretty formatting).
+    - Report events (info, success, error, etc.) are always printed with appropriate styling.
+    """
+
+    def __init__(self, raw_mode=False):
+        from janito.cli.console import shared_console
+
+        self.console = shared_console
+        self.raw_mode = raw_mode
+        import janito.report_events as report_events
+
+        super().__init__(driver_events, report_events)
+        self._waiting_printed = False
+
+    def on_RequestStarted(self, event):
+        # Print waiting message with provider name
+        provider = None
+        if hasattr(event, "payload") and isinstance(event.payload, dict):
+            provider = event.payload.get("provider_name")
+        if not provider:
+            provider = getattr(event, "provider_name", None)
+        if not provider:
+            provider = getattr(event, "driver_name", None)
+        if not provider:
+            provider = "LLM"
+        self.console.print(f"[bold cyan]Waiting for {provider}...[/bold cyan]", end="")
+
+    def on_ResponseReceived(self, event):
+        parts = event.parts if hasattr(event, "parts") else None
+        if not parts:
+            self.console.print("[No response parts to display]")
+            self.console.file.flush()
+            return
+        for part in parts:
+            if isinstance(part, message_parts.TextMessagePart):
+                self.console.print(Markdown(part.content))
+                self.console.file.flush()
+
+    def on_RequestFinished(self, event):
+        self.console.print("")  # Print end of line after waiting message
+        self._waiting_printed = False
+        response = event.response if hasattr(event, "response") else None
+        if response is not None:
+            if self.raw_mode:
+                self.console.print(Pretty(response, expand_all=True))
+                self.console.file.flush()
+            # Check for 'code' and 'event' fields in the response
+            code = None
+            event_field = None
+            if isinstance(response, dict):
+                code = response.get("code")
+                event_field = response.get("event")
+            if event_field is not None:
+                self.console.print(f"[bold yellow]Event:[/] {event_field}")
+                self.console.file.flush()
+        # No output if not raw_mode or if response is None
+
+    def on_ReportEvent(self, event):
+        msg = event.message if hasattr(event, "message") else None
+        subtype = event.subtype if hasattr(event, "subtype") else None
+        if not msg or not subtype:
+            return
+        if subtype == ReportSubtype.ACTION_INFO:
+            if getattr(event, "action", None) in (
+                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="")
+            self.console.file.flush()
+        elif subtype in (
+            ReportSubtype.SUCCESS,
+            ReportSubtype.ERROR,
+            ReportSubtype.WARNING,
+        ):
+            self.console.print(msg)
+            self.console.file.flush()
+        else:
+            self.console.print(msg)
+            self.console.file.flush()

janito/cli/single_shot_mode/__init__.py

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

janito/cli/single_shot_mode/handler.py

@@ -0,0 +1,137 @@
+"""
+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,
+)
+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):
+        self.args = args
+        self.provider_instance = provider_instance
+        self.llm_driver_config = llm_driver_config
+        self.role = role
+        from janito.agent.setup_agent import create_configured_agent
+
+        self.agent = create_configured_agent(
+            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),
+        )
+        # Setup conversation/history if needed
+        self.generic_handler = GenericPromptHandler(
+            args, [], provider_instance=provider_instance
+        )
+        self.generic_handler.agent = self.agent
+
+    def handle(self) -> None:
+        import traceback
+
+        user_prompt = " ".join(getattr(self.args, "user_prompt", [])).strip()
+        # UTF-8 sanitize user_prompt
+        sanitized = user_prompt
+        try:
+            sanitized.encode("utf-8")
+        except UnicodeEncodeError:
+            sanitized = sanitized.encode("utf-8", errors="replace").decode("utf-8")
+            shared_console.print(
+                "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
+            )
+        try:
+            self.generic_handler.handle_prompt(
+                sanitized,
+                args=self.args,
+                print_header=True,
+                raw=getattr(self.args, "raw", False),
+            )
+            if hasattr(self.args, "verbose_agent") and self.args.verbose_agent:
+                print("[debug] handle_prompt() completed without exception.")
+        except Exception as e:
+            print(
+                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]")
+        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"):
+            if (
+                hasattr(self.agent, "input_queue")
+                and self.agent.input_queue is not None
+            ):
+                self.agent.input_queue.put(None)
+            self.agent.join_driver()
+        try:
+            shared_console.file.flush()
+        except Exception:
+            pass
+        try:
+            import sys
+
+            sys.stdout.flush()
+        except Exception:
+            pass
+        # If event logger is active, flush event log

janito/cli/termweb_starter.py

@@ -4,9 +4,11 @@ import tempfile
 import time
 import http.client
 import os
+import threading
+import queue
 from rich.console import Console
-from janito.cli._termweb_log_utils import print_termweb_logs
 from janito.i18n import tr
+from janito.cli.config import get_termweb_port
 
 
 def wait_for_termweb(port, timeout=3.0):
@@ -25,49 +27,96 @@ def wait_for_termweb(port, timeout=3.0):
     return False
 
 
-def start_termweb(selected_port):
+def termweb_start_and_watch(shell_state, shellstate_lock, selected_port=None):
     """
-    Start the termweb server on the given port, with rich spinner and logging.
-    Returns (termweb_proc, started: bool)
+    Start the termweb server on the given port in a background thread.
+    Communicates (termweb_proc, started: bool, stdout_path, stderr_path) via result_queue if provided.
+    Returns the Thread object.
     """
-    console = Console()
-    with console.status("[cyan]Starting web server...", spinner="dots"):
-        # Step 1: Try source path
+
+    def termweb_worker(shell_state, shellstate_lock, selected_port, check_interval=2.0):
+        """
+        Worker to start termweb process, then monitor its running state/health, and update shell_state fields in a thread-safe manner.
+        - shell_state: context or state object to update (must provide .termweb_pid, .termweb_status, etc.)
+        - shellstate_lock: a threading.Lock or similar to synchronize access
+        """
+        console = Console()
+        # Try to locate app.py
         app_py_path = os.path.join(os.path.dirname(__file__), "..", "termweb", "app.py")
         app_py_path = os.path.abspath(app_py_path)
         if not os.path.isfile(app_py_path):
-            # Step 2: Try installed package
             try:
                 import janito_termweb
 
                 app_py_path = janito_termweb.__file__.replace("__init__.py", "app.py")
             except ImportError:
-                console.print("[red]Could not find termweb app.py![/red]")
-                return None, False, None, None
+                with shellstate_lock:
+                    shell_state.termweb_status = "notfound"
+                    shell_state.termweb_pid = None
+                    shell_state.termweb_stdout_path = None
+                    shell_state.termweb_stderr_path = None
+                return
         termweb_stdout = tempfile.NamedTemporaryFile(
             delete=False, mode="w+", encoding="utf-8"
         )
         termweb_stderr = tempfile.NamedTemporaryFile(
             delete=False, mode="w+", encoding="utf-8"
         )
+        port_to_use = selected_port if selected_port is not None else get_termweb_port()
         termweb_proc = subprocess.Popen(
-            [sys.executable, app_py_path, "--port", str(selected_port)],
+            [sys.executable, app_py_path, "--port", str(port_to_use)],
             stdout=termweb_stdout,
             stderr=termweb_stderr,
         )
-        if wait_for_termweb(selected_port, timeout=3.0):
-            console.print(
-                tr(
-                    "TermWeb started... Available at http://localhost:{selected_port}",
-                    selected_port=selected_port,
-                )
-            )
-            return termweb_proc, True, termweb_stdout.name, termweb_stderr.name
+
+        # Step 1: Wait for server to become healthy (initial check)
+        if wait_for_termweb(port_to_use, timeout=3.0):
+            with shellstate_lock:
+                shell_state.termweb_status = "running"
+                shell_state.termweb_pid = termweb_proc.pid
+                shell_state.termweb_stdout_path = termweb_stdout.name
+                shell_state.termweb_stderr_path = termweb_stderr.name
+                shell_state.termweb_port = port_to_use
         else:
             termweb_proc.terminate()
             termweb_proc.wait()
-            console.print(
-                f"[red]Failed to start TermWeb on port {selected_port}. Check logs for details.[/red]"
-            )
-            print_termweb_logs(termweb_stdout.name, termweb_stderr.name, console)
-            return None, False, termweb_stdout.name, termweb_stderr.name
+            # console.print(f"[red]Failed to start TermWeb on port {port_to_use}. Check logs for details.[/red]")
+            with shellstate_lock:
+                shell_state.termweb_status = "failed-start"
+                shell_state.termweb_pid = None
+                shell_state.termweb_stdout_path = termweb_stdout.name
+                shell_state.termweb_stderr_path = termweb_stderr.name
+                shell_state.termweb_port = None
+            return
+
+        # Step 2: Run watcher loop; exit and set fields if process or health fails
+        import time
+        from http.client import HTTPConnection
+
+        while True:
+            if termweb_proc.poll() is not None:  # means process exited
+                with shellstate_lock:
+                    shell_state.termweb_status = "terminated"
+                    shell_state.termweb_pid = None
+                break
+            try:
+                conn = HTTPConnection("localhost", port_to_use, timeout=0.5)
+                conn.request("GET", "/")
+                resp = conn.getresponse()
+                if resp.status != 200:
+                    raise Exception("Bad status")
+            except Exception:
+                # console.print(f"[red]TermWeb on port {port_to_use} appears to have stopped responding![/red]")
+                with shellstate_lock:
+                    shell_state.termweb_status = "unresponsive"
+                break
+            time.sleep(check_interval)
+
+    # Launch background thread
+    t = threading.Thread(
+        target=termweb_worker,
+        args=(shell_state, shellstate_lock, selected_port),
+        daemon=True,
+    )
+    t.start()
+    return t

janito/cli/utils.py

@@ -0,0 +1,25 @@
+"""
+Utility functions for janito CLI (shared).
+"""
+
+
+def format_tokens(n):
+    if n >= 1_000_000:
+        return f"{n/1_000_000:.2f}m"
+    elif n >= 1_000:
+        return f"{n/1_000:.2f}k"
+    else:
+        return str(n)
+
+
+def format_generation_time(generation_time_ms):
+    minutes = int(generation_time_ms // 60000)
+    seconds = int((generation_time_ms % 60000) // 1000)
+    milliseconds = int(generation_time_ms % 1000)
+    formatted_time = ""
+    if minutes > 0:
+        formatted_time += f"{minutes}m "
+    if seconds > 0:
+        formatted_time += f"{seconds}s "
+    formatted_time += f"[{int(generation_time_ms)} ms]"
+    return formatted_time