janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/__init__.py

@@ -1 +1,6 @@
-__version__ = "1.14.3"
+"""
+janito: A Python package for managing and interacting with Large Language Model (LLM) providers and their APIs.
+Provides a CLI for credential management and an extensible driver system for LLMs.
+"""
+
+__version__ = "2.0.1"

janito/__main__.py

@@ -1,4 +1,4 @@
-from janito.cli.main import main
+from .cli.main import main
 
 if __name__ == "__main__":
     main()

janito/agent/setup_agent.py

@@ -0,0 +1,139 @@
+from pathlib import Path
+from jinja2 import Template
+import importlib.resources
+import sys
+import warnings
+from janito.tools import get_local_tools_adapter
+from janito.llm.agent import LLMAgent
+from janito.drivers.driver_registry import get_driver_class
+from queue import Queue
+from janito.platform_discovery import PlatformDiscovery
+
+
+def setup_agent(
+    provider_instance,
+    llm_driver_config,
+    role=None,
+    templates_dir=None,
+    zero_mode=False,
+    input_queue=None,
+    output_queue=None,
+    verbose_tools=False,
+    verbose_agent=False,
+):
+    """
+    Creates an agent using a rendered system prompt template, passing an explicit role.
+    """
+    tools_provider = get_local_tools_adapter()
+    tools_provider.set_verbose_tools(verbose_tools)
+
+    if zero_mode:
+        # Pass provider to agent, let agent create driver
+        agent = LLMAgent(
+            provider_instance,
+            tools_provider,
+            agent_name=role or "software developer",
+            system_prompt=None,
+            verbose_agent=verbose_agent,
+        )
+        return agent
+    # Normal flow
+    if templates_dir is None:
+        # Set default template directory
+        templates_dir = Path(__file__).parent / "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: janito.agent.templates.profiles.system_prompt_template_main.txt.j2
+        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):
+            warnings.warn(
+                f"[janito] Could not find system_prompt_template_main.txt.j2 in {template_path} nor in janito.agent.templates.profiles package."
+            )
+            raise FileNotFoundError(
+                f"Template file not found in either {template_path} or package resource."
+            )
+
+    template = Template(template_content)
+    # Prepare context for Jinja2 rendering from llm_driver_config
+    # Compose context for Jinja2 rendering without using to_dict or temperature
+    context = {}
+    context["role"] = role or "software developer"
+    # Inject current platform environment information
+    pd = PlatformDiscovery()
+    context["platform"] = pd.get_platform_name()
+    context["python_version"] = pd.get_python_version()
+    context["shell_info"] = pd.detect_shell()
+    rendered_prompt = template.render(**context)
+    # Create the agent as before, now passing the explicit role
+    # Do NOT pass temperature; do not depend on to_dict
+    agent = LLMAgent(
+        provider_instance,
+        tools_provider,
+        agent_name=role or "software developer",
+        system_prompt=rendered_prompt,
+        input_queue=input_queue,
+        output_queue=output_queue,
+        verbose_agent=verbose_agent,
+    )
+    agent.template_vars["role"] = context["role"]
+    return agent
+
+
+def create_configured_agent(
+    *,
+    provider_instance=None,
+    llm_driver_config=None,
+    role=None,
+    verbose_tools=False,
+    verbose_agent=False,
+    templates_dir=None,
+    zero_mode=False,
+):
+    """
+    Normalizes agent setup for all CLI modes.
+
+    Args:
+        provider_instance: Provider instance for the agent
+        llm_driver_config: LLM driver configuration
+        role: Optional role string
+        verbose_tools: Optional, default False
+        verbose_agent: Optional, default False
+        templates_dir: Optional
+        zero_mode: Optional, default False
+
+    Returns:
+        Configured agent instance
+    """
+    # If provider_instance has create_driver, wire queues (single-shot mode)
+    input_queue = None
+    output_queue = None
+    driver = None
+    if hasattr(provider_instance, "create_driver"):
+        driver = provider_instance.create_driver()
+        driver.start()  # Ensure the driver background thread is started
+        input_queue = getattr(driver, "input_queue", None)
+        output_queue = getattr(driver, "output_queue", None)
+
+    agent = setup_agent(
+        provider_instance=provider_instance,
+        llm_driver_config=llm_driver_config,
+        role=role,
+        templates_dir=templates_dir,
+        zero_mode=zero_mode,
+        input_queue=input_queue,
+        output_queue=output_queue,
+        verbose_tools=verbose_tools,
+        verbose_agent=verbose_agent,
+    )
+    if driver is not None:
+        agent.driver = driver  # Attach driver to agent for thread management
+    return agent

janito/agent/templates/profiles/{system_prompt_template_base.txt.j2 → system_prompt_template_main.txt.j2}

@@ -3,7 +3,7 @@
 #}
 You are: {{ role }}
 
-You will answer following a pattern of: discovery, description, implementation (when a change was request) and validation.
+You will answer following a pattern of: discovery, description, implementation (when a change is requested) and validation.
 
 {# Improves tool selection and platform specific constrains, eg, path format, C:\ vs /path #}
 You will be using the following environment:

janito/cli/__init__.py

@@ -0,0 +1,9 @@
+# janito.cli package
+from .utils import format_tokens, format_generation_time
+
+__all__ = [
+    "setup_provider",
+    "setup_agent",
+    "format_tokens",
+    "format_generation_time",
+]

janito/cli/chat_mode/bindings.py

@@ -0,0 +1,37 @@
+"""
+Key bindings for Janito Chat CLI.
+"""
+
+from prompt_toolkit.key_binding import KeyBindings
+
+
+class KeyBindingsFactory:
+    @staticmethod
+    def create():
+        bindings = KeyBindings()
+
+        @bindings.add("c-y")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Yes"
+            buf.validate_and_handle()
+
+        @bindings.add("c-n")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "No"
+            buf.validate_and_handle()
+
+        @bindings.add("f1")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "/restart"
+            buf.validate_and_handle()
+
+        @bindings.add("f12")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Do It"
+            buf.validate_and_handle()
+
+        return bindings

janito/cli/chat_mode/chat_entry.py

@@ -0,0 +1,23 @@
+"""
+Main entry point for the Janito Chat CLI.
+Handles the interactive chat loop and session startup.
+"""
+
+from rich.console import Console
+from prompt_toolkit.formatted_text import HTML
+from janito.cli.chat_mode.session import ChatSession
+
+
+def main(args=None):
+    console = Console()
+    from janito.version import __version__
+
+    console.print(
+        f"[bold green]Welcome to the Janito Chat Mode (v{__version__})! Type /exit or press Ctrl+C to quit.[/bold green]"
+    )
+    session = ChatSession(console, args=args)
+    session.run()
+
+
+if __name__ == "__main__":
+    main()

janito/cli/chat_mode/prompt_style.py

@@ -0,0 +1,19 @@
+from prompt_toolkit.styles import Style
+
+chat_shell_style = Style.from_dict(
+    {
+        "prompt": "bg:#2323af #ffffff bold",
+        "": "bg:#005fdd #ffffff",  # blue background for input area
+        "bottom-toolbar": "fg:#2323af bg:yellow",
+        "key-label": "bg:#ff9500 fg:#232323 bold",
+        "provider": "fg:#117fbf",
+        "model": "fg:#1f5fa9",
+        "role": "fg:#e87c32 bold",
+        "msg_count": "fg:#5454dd",
+        "session_id": "fg:#704ab9",
+        "tokens_total": "fg:#a022c7",
+        "tokens_in": "fg:#00af5f",
+        "tokens_out": "fg:#01814a",
+        "max-tokens": "fg:#888888",
+    }
+)

janito/cli/chat_mode/session.py

@@ -0,0 +1,272 @@
+"""
+Session management for Janito Chat CLI.
+Defines ChatSession and ChatShellState classes.
+"""
+
+import types
+from rich.console import Console
+from rich.rule import Rule
+from prompt_toolkit.history import InMemoryHistory
+from janito.cli.chat_mode.shell.input_history import UserInputHistory
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit import PromptSession
+from janito.cli.chat_mode.toolbar import get_toolbar_func
+from prompt_toolkit.enums import EditingMode
+from janito.cli.chat_mode.prompt_style import chat_shell_style
+from janito.cli.chat_mode.bindings import KeyBindingsFactory
+from janito.cli.chat_mode.shell.commands import handle_command
+from janito.cli.chat_mode.shell.autocomplete import ShellCommandCompleter
+
+
+class ChatShellState:
+    def __init__(self, mem_history, conversation_history):
+        self.mem_history = mem_history
+        self.conversation_history = conversation_history
+        self.paste_mode = False
+        self.termweb_port = None
+        self.termweb_pid = None
+        self.termweb_stdout_path = None
+        self.termweb_stderr_path = None
+        self.livereload_stderr_path = None
+        self.termweb_status = "starting"  # Tracks the current termweb status (updated by background thread/UI)
+        self.termweb_live_status = (
+            None  # 'online', 'offline', updated by background checker
+        )
+        self.termweb_live_checked_time = None  # datetime.datetime of last status check
+        self.last_usage_info = {}
+        self.last_elapsed = None
+        self.main_agent = {}
+        self.mode = None
+        self.agent = None
+        self.main_agent = None
+        self.main_enabled = False
+
+
+class ChatSession:
+    def __init__(
+        self,
+        console,
+        provider_instance=None,
+        llm_driver_config=None,
+        role=None,
+        args=None,
+        verbose_tools=False,
+        verbose_agent=False,
+    ):
+        from janito.cli.prompt_core import PromptHandler as GenericPromptHandler
+
+        self._prompt_handler = GenericPromptHandler(
+            args=None,
+            conversation_history=(
+                None
+                if not hasattr(self, "shell_state")
+                else self.shell_state.conversation_history
+            ),
+            provider_instance=provider_instance,
+        )
+        self._prompt_handler.agent = None  # Will be set below if agent exists
+        self.console = console
+        self.user_input_history = UserInputHistory()
+        self.input_dicts = self.user_input_history.load()
+        self.mem_history = InMemoryHistory()
+        for item in self.input_dicts:
+            if isinstance(item, dict) and "input" in item:
+                self.mem_history.append_string(item["input"])
+        self.provider_instance = provider_instance
+        self.llm_driver_config = llm_driver_config
+        from janito.agent.setup_agent import create_configured_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,
+        )
+        from janito.conversation_history import LLMConversationHistory
+
+        self.shell_state = ChatShellState(self.mem_history, LLMConversationHistory())
+        self.shell_state.agent = agent
+        self.agent = agent
+        from janito.perf_singleton import performance_collector
+
+        self.performance_collector = performance_collector
+        self.key_bindings = KeyBindingsFactory.create()
+        # Attach agent to prompt handler now that agent is initialized
+        self._prompt_handler.agent = self.agent
+        self._prompt_handler.conversation_history = (
+            self.shell_state.conversation_history
+        )
+
+        # TERMWEB logic migrated from runner
+        self.termweb_support = False
+        if args and getattr(args, "web", False):
+            self.termweb_support = True
+            self.shell_state.termweb_support = self.termweb_support
+            from janito.cli.termweb_starter import termweb_start_and_watch
+            from janito.cli.config import get_termweb_port
+            import threading
+            from rich.console import Console
+
+            Console().print("[yellow]Starting termweb in background...[/yellow]")
+            self.termweb_lock = threading.Lock()
+            termweb_thread = termweb_start_and_watch(
+                self.shell_state, self.termweb_lock, get_termweb_port()
+            )
+            # Initial status is set to 'starting' by constructor; the watcher will update
+            self.termweb_thread = termweb_thread
+
+            # Start a background timer to update live termweb status (for UI responsiveness)
+            import threading, datetime
+
+            def update_termweb_liveness():
+                while True:
+                    with self.termweb_lock:
+                        port = getattr(self.shell_state, "termweb_port", None)
+                        if port:
+                            try:
+                                # is_termweb_running is removed; inline health check here:
+                                try:
+                                    import http.client
+
+                                    conn = http.client.HTTPConnection(
+                                        "localhost", port, timeout=0.5
+                                    )
+                                    conn.request("GET", "/")
+                                    resp = conn.getresponse()
+                                    running = resp.status == 200
+                                except Exception:
+                                    running = False
+                                self.shell_state.termweb_live_status = (
+                                    "online" if running else "offline"
+                                )
+                            except Exception:
+                                self.shell_state.termweb_live_status = "offline"
+                            self.shell_state.termweb_live_checked_time = (
+                                datetime.datetime.now()
+                            )
+                        else:
+                            self.shell_state.termweb_live_status = None
+                            self.shell_state.termweb_live_checked_time = (
+                                datetime.datetime.now()
+                            )
+                    # sleep outside lock
+                    threading.Event().wait(1.0)
+
+            self._termweb_liveness_thread = threading.Thread(
+                target=update_termweb_liveness, daemon=True
+            )
+            self._termweb_liveness_thread.start()
+            # No queue or blocking checks; UI (and timer) will observe self.shell_state fields
+
+        else:
+            self.shell_state.termweb_support = False
+            self.shell_state.termweb_status = "offline"
+
+    def run(self):
+        session = self._create_prompt_session()
+        self.console.print(
+            "[bold green]Type /help for commands. Type /exit or press Ctrl+C to quit.[/bold green]"
+        )
+        self._chat_loop(session)
+
+    def _chat_loop(self, session):
+        self.msg_count = 0
+        timer_started = False
+        while True:
+            if not timer_started:
+                timer_started = True
+            cmd_input = self._handle_input(session)
+            if cmd_input is None:
+                break
+            if not cmd_input:
+                continue
+            if self._handle_exit_conditions(cmd_input):
+                break
+            if cmd_input.startswith("/"):
+                handle_command(cmd_input, shell_state=self.shell_state)
+                continue
+            self.user_input_history.append(cmd_input)
+            try:
+                final_event = (
+                    self._prompt_handler.agent.last_event
+                    if hasattr(self._prompt_handler.agent, "last_event")
+                    else None
+                )
+                self._prompt_handler.run_prompt(cmd_input)
+                self.msg_count += 1
+                # After prompt, print the stat line using the shared core function
+                from janito.formatting_token import print_token_message_summary
+
+                usage = self.performance_collector.get_last_request_usage()
+                print_token_message_summary(self.console, self.msg_count, usage)
+                # Print exit reason if present in the final event
+                if final_event and hasattr(final_event, "metadata"):
+                    exit_reason = (
+                        final_event.metadata.get("exit_reason")
+                        if hasattr(final_event, "metadata")
+                        else None
+                    )
+                    if exit_reason:
+                        self.console.print(
+                            f"[bold yellow]Exit reason: {exit_reason}[/bold yellow]"
+                        )
+
+            except Exception as exc:
+                self.console.print(f"[red]Exception in agent: {exc}[/red]")
+                import traceback
+
+                self.console.print(traceback.format_exc())
+
+    def _create_prompt_session(self):
+        return PromptSession(
+            style=chat_shell_style,
+            completer=ShellCommandCompleter(),
+            history=self.mem_history,
+            editing_mode=EditingMode.EMACS,
+            key_bindings=self.key_bindings,
+            bottom_toolbar=lambda: get_toolbar_func(
+                self.performance_collector, 0, self.shell_state
+            )(),
+        )
+
+    def _handle_input(self, session):
+        injected = getattr(self.shell_state, "injected_input", None)
+        if injected is not None:
+            cmd_input = injected
+            self.shell_state.injected_input = None
+        else:
+            try:
+                cmd_input = session.prompt(HTML("<inputline>💬 </inputline>"))
+            except (KeyboardInterrupt, EOFError):
+                self._handle_exit()
+                return None
+        sanitized = cmd_input.strip()
+        # Ensure UTF-8 validity and sanitize if needed
+        try:
+            # This will raise UnicodeEncodeError if not encodable
+            sanitized.encode("utf-8")
+        except UnicodeEncodeError:
+            # Replace invalid characters
+            sanitized = sanitized.encode("utf-8", errors="replace").decode("utf-8")
+            self.console.print(
+                "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
+            )
+        return sanitized
+
+    def _handle_exit(self):
+        self.console.print("[bold yellow]Exiting chat. Goodbye![/bold yellow]")
+        # Ensure driver thread is joined before exit
+        if hasattr(self, "agent") and 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()
+
+    def _handle_exit_conditions(self, cmd_input):
+        if cmd_input.lower() in ("/exit", ":q", ":quit"):
+            self._handle_exit()
+            return True
+        return False

janito/{shell/prompt/completer.py → cli/chat_mode/shell/autocomplete.py}

@@ -1,15 +1,16 @@
 from prompt_toolkit.completion import Completer, Completion
+from janito.cli.chat_mode.shell.commands import get_shell_command_names
 
 
 class ShellCommandCompleter(Completer):
-    def __init__(self):
-        # Import here to avoid circular import at module level
-        from janito.shell.commands import COMMAND_HANDLERS
+    """
+    Provides autocomplete suggestions for shell commands starting with '/'.
+    Uses the COMMAND_HANDLERS registry for available commands.
+    """
 
+    def __init__(self):
         # Only commands starting with '/'
-        self.commands = sorted(
-            [cmd for cmd in COMMAND_HANDLERS.keys() if cmd.startswith("/")]
-        )
+        self.commands = get_shell_command_names()
 
     def get_completions(self, document, complete_event):
         text = document.text_before_cursor

janito/cli/chat_mode/shell/commands/__init__.py

@@ -0,0 +1,55 @@
+from .base import ShellCmdHandler
+from .edit import EditShellHandler
+from .history_view import ViewShellHandler
+from .lang import LangShellHandler
+from .livelogs import LivelogsShellHandler
+from .last import LastShellHandler
+from .prompt import PromptShellHandler, RoleShellHandler, ProfileShellHandler
+from .multi import MultiShellHandler
+from .role import RoleCommandShellHandler
+from .session import HistoryShellHandler
+from .termweb_log import TermwebLogTailShellHandler
+from .tools import ToolsShellHandler
+from .help import HelpShellHandler
+from janito.cli.console import shared_console
+
+COMMAND_HANDLERS = {
+    "/clear": __import__(
+        "janito.cli.chat_mode.shell.commands.clear", fromlist=["ClearShellHandler"]
+    ).ClearShellHandler,
+    "/restart": __import__(
+        "janito.cli.chat_mode.shell.commands.conversation_restart",
+        fromlist=["RestartShellHandler"],
+    ).RestartShellHandler,
+    "/edit": EditShellHandler,
+    "/view": ViewShellHandler,
+    "/lang": LangShellHandler,
+    "/livelogs": LivelogsShellHandler,
+    "/last": LastShellHandler,
+    "/prompt": PromptShellHandler,
+    "/role": RoleShellHandler,
+    "/profile": ProfileShellHandler,
+    "/history": HistoryShellHandler,
+    "/termweb-logs": TermwebLogTailShellHandler,
+    "/tools": ToolsShellHandler,
+    "/multi": MultiShellHandler,
+    "/help": HelpShellHandler,
+}
+
+
+def get_shell_command_names():
+    return sorted(cmd for cmd in COMMAND_HANDLERS.keys() if cmd.startswith("/"))
+
+
+def handle_command(command, shell_state=None):
+    parts = command.strip().split(maxsplit=1)
+    cmd = parts[0]
+    after_cmd_line = parts[1] if len(parts) > 1 else ""
+    handler_cls = COMMAND_HANDLERS.get(cmd)
+    if handler_cls:
+        handler = handler_cls(after_cmd_line=after_cmd_line, shell_state=shell_state)
+        return handler.run()
+    shared_console.print(
+        f"[bold red]Invalid command: {cmd}. Type /help for a list of commands.[/bold red]"
+    )
+    return None

janito/cli/chat_mode/shell/commands/base.py

@@ -0,0 +1,9 @@
+class ShellCmdHandler:
+    help_text = ""
+
+    def __init__(self, after_cmd_line=None, shell_state=None):
+        self.after_cmd_line = after_cmd_line
+        self.shell_state = shell_state
+
+    def run(self):
+        raise NotImplementedError("Subclasses must implement run()")

janito/cli/chat_mode/shell/commands/clear.py

@@ -0,0 +1,12 @@
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class ClearShellHandler(ShellCmdHandler):
+    help_text = "Clear the terminal screen using Rich console."
+
+    def run(self):
+        shared_console.clear()
+        # Optionally show a message after clearing
+        # shared_console.print("[green]Screen cleared.[/green]")
+        return None