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

janito/shell/commands/livelogs.py

@@ -1,42 +0,0 @@
-def handle_livelogs(console, args=None, shell_state=None, **kwargs):
-    lines = 20
-    if args and len(args) > 0 and str(args[0]).isdigit():
-        lines = int(args[0])
-    stdout_path = shell_state.termweb_stdout_path if shell_state else None
-    stderr_path = shell_state.livereload_stderr_path if shell_state else None
-    if not stdout_path and not stderr_path:
-        console.print(
-            "[yellow][livereload] No livereload log files found for this session.[/yellow]"
-        )
-        return
-    stdout_lines = []
-    stderr_lines = []
-    if stdout_path:
-        try:
-            with open(stdout_path, encoding="utf-8") as f:
-                stdout_lines = f.readlines()[-lines:]
-            if stdout_lines:
-                console.print(
-                    f"[yellow][livereload][stdout] Tail of {stdout_path}:\n"
-                    + "".join(stdout_lines)
-                )
-        except Exception as e:
-            console.print(f"[red][livereload][stdout] Error: {e}[/red]")
-    if stderr_path:
-        try:
-            with open(stderr_path, encoding="utf-8") as f:
-                stderr_lines = f.readlines()[-lines:]
-            if stderr_lines:
-                console.print(
-                    f"[red][livereload][stderr] Tail of {stderr_path}:\n"
-                    + "".join(stderr_lines)
-                )
-        except Exception as e:
-            console.print(f"[red][livereload][stderr] Error: {e}[/red]")
-    if (not stdout_path or not stdout_lines) and (not stderr_path or not stderr_lines):
-        console.print("[livereload] No output or errors captured in logs.")
-
-
-handle_livelogs.help_text = (
-    "Show live updates from the server log file (default: server.log)"
-)

janito/shell/commands/prompt.py

@@ -1,62 +0,0 @@
-from janito.agent.runtime_config import runtime_config
-
-
-def handle_prompt(console, shell_state=None, **kwargs):
-    profile_manager = kwargs.get("profile_manager")
-    if not profile_manager and shell_state and hasattr(shell_state, "profile_manager"):
-        profile_manager = shell_state.profile_manager
-    prompt = None
-    if profile_manager:
-        prompt = profile_manager.system_prompt_template
-        if not prompt:
-            profile_manager.refresh_prompt()
-            prompt = profile_manager.system_prompt_template
-    if not prompt:
-        console.print(
-            "[bold red]System prompt is not initialized. Please check your profile configuration.[/bold red]"
-        )
-    else:
-        console.print(f"[bold magenta]System Prompt:[/bold magenta]\n{prompt}")
-
-
-handle_prompt.help_text = "Show the system prompt"
-
-
-def handle_role(console, args=None, shell_state=None, **kwargs):
-    profile_manager = (
-        shell_state.profile_manager
-        if shell_state and hasattr(shell_state, "profile_manager")
-        else kwargs.get("profile_manager")
-    )
-    if not args:
-        console.print("[bold red]Usage: /role <new role description>[/bold red]")
-        return
-    new_role = " ".join(args)
-    if profile_manager:
-        profile_manager.set_role(new_role)
-    # Update system message in conversation
-    found = False
-    for msg in shell_state.conversation_history.get_messages():
-        if msg.get("role") == "system":
-            msg["content"] = (
-                profile_manager.system_prompt_template if profile_manager else new_role
-            )
-            found = True
-            break
-    if not found:
-        if shell_state and hasattr(shell_state, "conversation_history"):
-            shell_state.conversation_history.set_system_message(new_role)
-    # Also store the raw role string
-    if profile_manager:
-        setattr(profile_manager, "role_name", new_role)
-    runtime_config.set("role", new_role)
-    console.print(f"[bold green]System role updated to:[/bold green] {new_role}")
-
-
-handle_role.help_text = "Change the system role"
-
-
-def handle_profile(console, *args, **kwargs):
-    """/profile - Show the current and available Agent Profile (only 'base' is supported)"""
-    console.print("[bold green]Current profile:[/bold green] base")
-    console.print("[bold yellow]Available profiles:[/bold yellow]\n- base")

janito/shell/commands/termweb_log.py

@@ -1,94 +0,0 @@
-import http.client
-from rich.console import Console
-from janito.agent.runtime_config import runtime_config
-
-
-def is_termweb_running(port):
-    """Check if termweb is running by making an HTTP request to the root endpoint."""
-    try:
-        conn = http.client.HTTPConnection("localhost", port, timeout=0.5)
-        conn.request("GET", "/")
-        resp = conn.getresponse()
-        return resp.status == 200
-    except Exception:
-        return False
-
-
-def handle_termweb_log_tail(console: Console, *args, shell_state=None, **kwargs):
-    lines = 20
-    if args and args[0].isdigit():
-        lines = int(args[0])
-    stdout_path = shell_state.termweb_stdout_path if shell_state else None
-    stderr_path = shell_state.termweb_stderr_path if shell_state else None
-    if not stdout_path and not stderr_path:
-        console.print(
-            "[yellow][termweb] No termweb log files found for this session.[/yellow]"
-        )
-        return
-    if stdout_path:
-        try:
-            with open(stdout_path, encoding="utf-8") as f:
-                stdout_lines = f.readlines()[-lines:]
-            if stdout_lines:
-                console.print(
-                    f"[yellow][termweb][stdout] Tail of {stdout_path}:\n"
-                    + "".join(stdout_lines)
-                )
-        except Exception:
-            pass
-    if stderr_path:
-        try:
-            with open(stderr_path, encoding="utf-8") as f:
-                stderr_lines = f.readlines()[-lines:]
-            if stderr_lines:
-                console.print(
-                    f"[red][termweb][stderr] Tail of {stderr_path}:\n"
-                    + "".join(stderr_lines)
-                )
-        except Exception:
-            pass
-    if (not stdout_path or not stdout_lines) and (not stderr_path or not stderr_lines):
-        console.print("[termweb] No output or errors captured in logs.")
-
-
-handle_termweb_log_tail.help_text = "Show the last lines of the latest termweb logs"
-
-
-def handle_termweb_status(console: Console, *args, shell_state=None, **kwargs):
-    if shell_state is None:
-        console.print(
-            "[red]No shell state available. Cannot determine termweb status.[/red]"
-        )
-        return
-    port = getattr(shell_state, "termweb_port", None)
-    port_source = "shell_state"
-    if not port:
-        port = runtime_config.get("termweb_port")
-        port_source = "runtime_config"
-    pid = getattr(shell_state, "termweb_pid", None)
-    stdout_path = getattr(shell_state, "termweb_stdout_path", None)
-    stderr_path = getattr(shell_state, "termweb_stderr_path", None)
-    running = False
-    if port:
-        running = is_termweb_running(port)
-    console.print("[bold cyan]TermWeb Server Status:[/bold cyan]")
-    console.print(f"  Running: {'[green]Yes[/green]' if running else '[red]No[/red]'}")
-    if pid:
-        console.print(f"  PID: {pid}")
-    if port:
-        console.print(f"  Port: {port} (from {port_source})")
-        url = f"http://localhost:{port}/"
-        console.print(f"  URL: [underline blue]{url}[/underline blue]")
-    else:
-        console.print(
-            "  [yellow]No port configured in state or runtime_config.[/yellow]"
-        )
-    if stdout_path:
-        console.print(f"  Stdout log: {stdout_path}")
-    if stderr_path:
-        console.print(f"  Stderr log: {stderr_path}")
-
-
-handle_termweb_status.help_text = (
-    "Show status information about the running termweb server"
-)

janito/shell/commands/tools.py

@@ -1,26 +0,0 @@
-from janito.agent.tool_registry import get_tool_schemas
-from rich.table import Table
-
-
-def handle_tools(console, args=None, shell_state=None):
-    table = Table(title="Available Tools", show_lines=True, style="bold magenta")
-    table.add_column("Name", style="cyan", no_wrap=True)
-    table.add_column("Description", style="green")
-    table.add_column("Parameters", style="yellow")
-    try:
-        for schema in get_tool_schemas():
-            fn = schema["function"]
-            params = "\n".join(
-                [
-                    f"[bold]{k}[/]: {v['type']}"
-                    for k, v in fn["parameters"].get("properties", {}).items()
-                ]
-            )
-            table.add_row(f"[b]{fn['name']}[/b]", fn["description"], params or "-")
-    except Exception as e:
-        console.print(f"[red]Error loading tools: {e}[/red]")
-        return
-    console.print(table)
-
-
-handle_tools.help_text = "List available tools"

janito/shell/commands/track.py

@@ -1,36 +0,0 @@
-from janito.agent.tool_use_tracker import ToolUseTracker
-from rich.console import Console
-from rich.table import Table
-
-
-def handle_track(console: Console, args=None, shell_state=None):
-    tracker = ToolUseTracker.instance()
-    history = tracker.get_history()
-    if not history:
-        console.print("[bold yellow]No tool usage history found.[/bold yellow]")
-        return
-    table = Table(show_header=True, header_style="bold magenta")
-    table.add_column("#", style="dim", width=4)
-    table.add_column("Tool")
-    table.add_column("Params/Result")
-    for idx, entry in enumerate(history, 1):
-        tool = entry["tool"]
-        params = entry["params"].copy()
-        result = entry.get("result", "")
-        # For create/replace file, trim content in params only
-        if tool in ("create_file", "replace_file") and "content" in params:
-            content = params["content"]
-            if isinstance(content, str):
-                lines = content.splitlines()
-                if len(lines) > 3:
-                    params["content"] = (
-                        "\n".join(lines[:2])
-                        + f"\n... (trimmed, {len(lines)} lines total)"
-                    )
-                elif len(content) > 120:
-                    params["content"] = content[:120] + "... (trimmed)"
-                else:
-                    params["content"] = content
-        param_result = f"{params}\n--- Result ---\n{result}" if result else str(params)
-        table.add_row(str(idx), tool, param_result)
-    console.print(table)

janito/shell/main.py

@@ -1,326 +0,0 @@
-from janito.agent.rich_message_handler import RichMessageHandler
-from prompt_toolkit.history import InMemoryHistory
-from dataclasses import dataclass, field
-from typing import Optional, Any, Dict
-from janito.shell.prompt.session_setup import (
-    setup_prompt_session,
-    print_welcome_message,
-)
-from janito.shell.commands import handle_command
-from janito.agent.conversation_exceptions import EmptyResponseError, ProviderError
-from janito.agent.api_exceptions import ApiError
-from janito.agent.llm_conversation_history import LLMConversationHistory
-import janito.i18n as i18n
-from janito.agent.runtime_config import runtime_config
-from rich.console import Console
-import os
-from janito.shell.session.manager import get_session_id
-from prompt_toolkit.formatted_text import HTML
-import time
-from janito.shell.input_history import UserInputHistory
-
-
-@dataclass
-class ShellState:
-    mem_history: Any = field(default_factory=InMemoryHistory)
-    conversation_history: Any = field(default_factory=lambda: LLMConversationHistory())
-    last_usage_info: Dict[str, int] = field(
-        default_factory=lambda: {
-            "prompt_tokens": 0,
-            "completion_tokens": 0,
-            "total_tokens": 0,
-        }
-    )
-    last_elapsed: Optional[float] = None
-    termweb_stdout_path: Optional[str] = None
-    termweb_stderr_path: Optional[str] = None
-    livereload_stdout_path: Optional[str] = None
-    livereload_stderr_path: Optional[str] = None
-    paste_mode: bool = False
-    profile_manager: Optional[Any] = None
-    user_input_history: Optional[Any] = None
-
-
-# Track the active prompt session for cleanup
-active_prompt_session = None
-
-
-def load_session(shell_state, continue_session, session_id, profile_manager):
-    from janito.shell.session.manager import load_conversation_by_session_id
-
-    if continue_session and session_id:
-        try:
-            messages, prompts, usage = load_conversation_by_session_id(session_id)
-        except FileNotFoundError as e:
-            shell_state.profile_manager.agent.message_handler.console.print(
-                f"[bold red]{str(e)}[/bold red]"
-            )
-            return False
-        shell_state.conversation_history = LLMConversationHistory(messages)
-        conversation_history = shell_state.conversation_history
-        found = False
-        for msg in conversation_history.get_messages():
-            if msg.get("role") == "system":
-                msg["content"] = profile_manager.system_prompt_template
-                found = True
-                break
-        if not found:
-            conversation_history.set_system_message(
-                profile_manager.system_prompt_template
-            )
-        shell_state.last_usage_info = usage or {}
-    else:
-        conversation_history = shell_state.conversation_history
-        if (
-            profile_manager.system_prompt_template
-            and (
-                not runtime_config.get("vanilla_mode", False)
-                or runtime_config.get("system_prompt_template")
-            )
-            and not any(
-                m.get("role") == "system" for m in conversation_history.get_messages()
-            )
-        ):
-            conversation_history.set_system_message(
-                profile_manager.system_prompt_template
-            )
-    return True
-
-
-def _handle_exit_confirmation(session, message_handler, conversation_history):
-    try:
-        confirm = (
-            session.prompt(
-                HTML("<inputline>Do you really want to exit? (y/n): </inputline>")
-            )
-            .strip()
-            .lower()
-        )
-    except KeyboardInterrupt:
-        message_handler.handle_message({"type": "error", "message": "Exiting..."})
-        return True
-    if confirm == "y":
-        message_handler.handle_message({"type": "error", "message": "Exiting..."})
-        conversation_history.add_message(
-            {"role": "system", "content": "[Session ended by user]"}
-        )
-        return True
-    return False
-
-
-def _handle_shell_command(user_input, console):
-    command = user_input.strip()[1:].strip()
-    if command:
-        console.print(f"[bold cyan]Executing shell command:[/] {command}")
-        exit_code = os.system(command)
-        console.print(f"[green]Command exited with code {exit_code}[/green]")
-    else:
-        console.print("[red]No command provided after ![/red]")
-
-
-def _handle_prompt_command(user_input, console, shell_state, conversation_history):
-    result = handle_command(
-        user_input.strip(),
-        console,
-        shell_state=shell_state,
-    )
-    if result == "exit":
-        conversation_history.add_message(
-            {"role": "system", "content": "[Session ended by user]"}
-        )
-        return True
-    return False
-
-
-def handle_prompt_loop(
-    shell_state, session, profile_manager, agent, max_rounds, session_id
-):
-    global active_prompt_session
-    conversation_history = shell_state.conversation_history
-    message_handler = RichMessageHandler()
-    console = message_handler.console
-    while True:
-        try:
-            if shell_state.paste_mode:
-                user_input = session.prompt("Multiline> ", multiline=True)
-                was_paste_mode = True
-                shell_state.paste_mode = False
-            else:
-                user_input = session.prompt(
-                    HTML("<inputline>💬 </inputline>"), multiline=False
-                )
-                was_paste_mode = False
-        except EOFError:
-            console.print("\n[bold red]Exiting...[/bold red]")
-            break
-        except KeyboardInterrupt:
-            console.print()
-            if _handle_exit_confirmation(
-                session, message_handler, conversation_history
-            ):
-                break
-            else:
-                continue
-        # Handle !cmd command: execute shell command with os.system
-        if user_input.strip().startswith("!"):
-            _handle_shell_command(user_input, console)
-            continue
-
-        cmd_input = user_input.strip().lower()
-        if not was_paste_mode and (cmd_input.startswith("/") or cmd_input == "exit"):
-            if _handle_prompt_command(
-                user_input, console, shell_state, conversation_history
-            ):
-                break
-            continue
-        if not user_input.strip():
-            continue
-        shell_state.mem_history.append_string(user_input)
-        shell_state.user_input_history.append(user_input)
-        conversation_history.add_message({"role": "user", "content": user_input})
-        handle_chat(shell_state, profile_manager, agent, max_rounds, session_id)
-    # Save conversation history after exiting
-    save_conversation_history(conversation_history, session_id)
-
-
-def handle_keyboard_interrupt(conversation_history, message_handler):
-    removed_count = 0
-    while (
-        conversation_history.last_message()
-        and conversation_history.last_message().get("role") != "assistant"
-    ):
-        conversation_history.remove_last_message()
-        removed_count += 1
-    # Remove the assistant message itself, if present
-    if (
-        conversation_history.last_message()
-        and conversation_history.last_message().get("role") == "assistant"
-    ):
-        conversation_history.remove_last_message()
-        removed_count += 1
-    message_handler.handle_message(
-        {
-            "type": "info",
-            "message": f"\nLast turn cleared due to interruption. Returning to prompt. (removed {removed_count} last msgs)\n",
-        }
-    )
-
-
-def handle_chat_error(message_handler, error_type, error):
-    if error_type == "ProviderError":
-        message_handler.handle_message(
-            {"type": "error", "message": f"Provider error: {error}"}
-        )
-    elif error_type == "EmptyResponseError":
-        message_handler.handle_message({"type": "error", "message": f"Error: {error}"})
-    elif error_type == "ApiError":
-        message_handler.handle_message({"type": "error", "message": str(error)})
-    elif error_type == "Exception":
-        import traceback
-
-        tb = traceback.format_exc()
-        message_handler.handle_message(
-            {
-                "type": "error",
-                "message": f"Unexpected error: {error}\n{tb}\nReturning to prompt.",
-            }
-        )
-
-
-def handle_chat(shell_state, profile_manager, agent, max_rounds, session_id):
-    conversation_history = shell_state.conversation_history
-    message_handler = RichMessageHandler()
-    console = message_handler.console
-    start_time = time.time()
-    try:
-        response = profile_manager.agent.chat(
-            conversation_history,
-            max_rounds=max_rounds,
-            message_handler=message_handler,
-            spinner=True,
-        )
-    except KeyboardInterrupt:
-        handle_keyboard_interrupt(conversation_history, message_handler)
-        return
-    except ProviderError as e:
-        handle_chat_error(message_handler, "ProviderError", e)
-        return
-    except EmptyResponseError as e:
-        handle_chat_error(message_handler, "EmptyResponseError", e)
-        return
-    except ApiError as e:
-        handle_chat_error(message_handler, "ApiError", e)
-        return
-    except Exception as e:
-        handle_chat_error(message_handler, "Exception", e)
-        return
-    shell_state.last_elapsed = time.time() - start_time
-    usage = response.get("usage")
-    if usage:
-        for k in ("prompt_tokens", "completion_tokens", "total_tokens"):
-            shell_state.last_usage_info[k] = usage.get(k, 0)
-    content = response.get("content")
-    if content and (
-        len(conversation_history) == 0
-        or conversation_history.get_messages()[-1].get("role") != "assistant"
-    ):
-        conversation_history.add_message({"role": "assistant", "content": content})
-
-
-def save_conversation_history(conversation_history, session_id):
-    from janito.shell.session.manager import get_session_id
-
-    history_dir = os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
-    os.makedirs(history_dir, exist_ok=True)
-    session_id_to_save = session_id if session_id else get_session_id()
-    history_path = os.path.join(history_dir, f"{session_id_to_save}.json")
-    conversation_history.to_json_file(history_path)
-
-
-def start_chat_shell(
-    profile_manager,
-    continue_session=False,
-    session_id=None,
-    max_rounds=100,
-    termweb_stdout_path=None,
-    termweb_stderr_path=None,
-    livereload_stdout_path=None,
-    livereload_stderr_path=None,
-):
-    i18n.set_locale(runtime_config.get("lang", "en"))
-    global active_prompt_session
-    agent = profile_manager.agent
-    message_handler = RichMessageHandler()
-    console = message_handler.console
-    console.clear()
-    shell_state = ShellState()
-    shell_state.profile_manager = profile_manager
-    profile_manager.refresh_prompt()
-    user_input_history = UserInputHistory()
-    user_input_dicts = user_input_history.load()
-    mem_history = shell_state.mem_history
-    for item in user_input_dicts:
-        if isinstance(item, dict) and "input" in item:
-            mem_history.append_string(item["input"])
-    shell_state.user_input_history = user_input_history
-    if not load_session(shell_state, continue_session, session_id, profile_manager):
-        return
-
-    def last_usage_info_ref():
-        return shell_state.last_usage_info
-
-    last_elapsed = shell_state.last_elapsed
-    print_welcome_message(console, continue_id=session_id if continue_session else None)
-    session = setup_prompt_session(
-        lambda: shell_state.conversation_history.get_messages(),
-        last_usage_info_ref,
-        last_elapsed,
-        mem_history,
-        profile_manager,
-        agent,
-        lambda: shell_state.conversation_history,
-    )
-    active_prompt_session = session
-    handle_prompt_loop(
-        shell_state, session, profile_manager, agent, max_rounds, session_id
-    )

janito/shell/prompt/load_prompt.py

@@ -1,57 +0,0 @@
-import os
-import importlib.resources
-
-
-def load_prompt(filename=None):
-    """
-    Load the system prompt from a file. If filename is None, use the default prompt file.
-    Returns the prompt string.
-    Tries source path first, then falls back to importlib.resources for installed packages.
-    """
-    default_rel_path = os.path.normpath(
-        os.path.join(
-            os.path.dirname(__file__),
-            "../agent/templates/profiles/system_prompt_template_default.j2",
-        )
-    )
-    if filename is None:
-        filename = default_rel_path
-
-    # Try loading from source path first
-    abs_path = os.path.abspath(filename)
-    if os.path.exists(abs_path):
-        with open(abs_path, "r", encoding="utf-8") as f:
-            return f.read()
-
-    # If not found, try importlib.resources (for installed package)
-    try:
-        # Remove leading directories up to 'janito/agent/templates'
-        # and get the relative path inside the package
-        resource_path = filename
-        for marker in ["janito/agent/templates/", "agent/templates/"]:
-            idx = filename.replace("\\", "/").find(marker)
-            if idx != -1:
-                resource_path = filename[idx + len("janito/agent/templates/") :]
-                break
-
-        # Try loading from janito.agent.templates.profiles
-        if resource_path.startswith("profiles/"):
-            package = "janito.agent.templates.profiles"
-            resource = resource_path[len("profiles/") :]
-        elif resource_path.startswith("features/"):
-            package = "janito.agent.templates.features"
-            resource = resource_path[len("features/") :]
-        else:
-            package = "janito.agent.templates"
-            resource = resource_path
-
-        with (
-            importlib.resources.files(package)
-            .joinpath(resource)
-            .open("r", encoding="utf-8") as f
-        ):
-            return f.read()
-    except Exception as e:
-        raise FileNotFoundError(
-            f"Prompt file not found at '{abs_path}' or in package resources: {e}"
-        )