janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/cli/one_shot.py

@@ -0,0 +1,80 @@
+from janito.agent.conversation_exceptions import (
+    MaxRoundsExceededError,
+    ProviderError,
+    EmptyResponseError,
+)
+from janito.agent.api_exceptions import ApiError
+from janito.agent.llm_conversation_history import LLMConversationHistory
+
+
+def prepare_messages(args, profile_manager, runtime_config):
+    prompt = getattr(args, "input_arg", None)
+    messages = []
+    system_prompt_override = runtime_config.get("system_prompt_template")
+    if system_prompt_override:
+        if not runtime_config.get("vanilla_mode", False) or getattr(
+            args, "system", None
+        ):
+            messages.append({"role": "system", "content": system_prompt_override})
+    elif profile_manager.system_prompt_template and not runtime_config.get(
+        "vanilla_mode", False
+    ):
+        messages.append(
+            {"role": "system", "content": profile_manager.system_prompt_template}
+        )
+    messages.append({"role": "user", "content": prompt})
+    return messages
+
+
+def print_usage_info(args, info_start_time, result, console):
+    if (
+        getattr(args, "info", False)
+        and info_start_time is not None
+        and result is not None
+    ):
+        usage_info = result.get("usage")
+        total_tokens = usage_info.get("total_tokens") if usage_info else None
+        prompt_tokens = usage_info.get("prompt_tokens") if usage_info else None
+        completion_tokens = usage_info.get("completion_tokens") if usage_info else None
+        elapsed = time.time() - info_start_time
+        console.print(
+            f"[bold green]Total tokens:[/] [yellow]{total_tokens}[/yellow] [bold green]| Input:[/] [cyan]{prompt_tokens}[/cyan] [bold green]| Output:[/] [magenta]{completion_tokens}[/magenta] [bold green]| Elapsed:[/] [yellow]{elapsed:.2f}s[/yellow]",
+            style="dim",
+        )
+
+
+def run_oneshot_mode(args, profile_manager, runtime_config):
+    from rich.console import Console
+    from janito.agent.rich_message_handler import RichMessageHandler
+    import time
+
+    console = Console()
+    message_handler = RichMessageHandler()
+    messages = prepare_messages(args, profile_manager, runtime_config)
+    info_start_time = None
+    if getattr(args, "info", False):
+        info_start_time = time.time()
+    try:
+        max_rounds = 100
+        result = profile_manager.agent.chat(
+            LLMConversationHistory(messages),
+            message_handler=message_handler,
+            spinner=True,
+            max_rounds=max_rounds,
+        )
+        print_usage_info(args, info_start_time, result, console)
+    except MaxRoundsExceededError:
+        console.print("[red]Max conversation rounds exceeded.[/red]")
+    except ProviderError as e:
+        console.print(f"[red]Provider error:[/red] {e}")
+    except EmptyResponseError as e:
+        console.print(f"[red]Error:[/red] {e}")
+    except ApiError as e:
+        if "maximum context length" in str(e):
+            console.print(
+                f"[red]Error:[/red] {e}\n[bold yellow]Tip:[/] Try using [green]--max-tokens[/green] with a lower value."
+            )
+        else:
+            console.print(f"[red]API error:[/red] {e}")
+    except Exception:
+        raise

janito/cli/termweb_starter.py

@@ -5,7 +5,7 @@ import time
 import http.client
 import os
 from rich.console import Console
-from janito.cli.runner._termweb_log_utils import print_termweb_logs
+from janito.cli._termweb_log_utils import print_termweb_logs
 from janito.i18n import tr
 
 
@@ -69,5 +69,5 @@ def start_termweb(selected_port):
             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)
+            print_termweb_logs(termweb_stdout.name, termweb_stderr.name, console)
             return None, False, termweb_stdout.name, termweb_stderr.name

janito/i18n/__init__.py

@@ -23,7 +23,7 @@ def set_locale(locale):
 
 def tr(msg, **kwargs):
     """Translate message to current locale, usando hash SHA-1 da mensagem como chave."""
-    msg_hash = hashlib.sha1(msg.encode("utf-8")).hexdigest()
+    msg_hash = hashlib.sha1(msg.encode("utf-8", errors="surrogatepass")).hexdigest()
     template = _translations.get(msg_hash, msg)
     try:
         return template.format(**kwargs)

janito/livereload/app.py

@@ -0,0 +1,25 @@
+import sys
+import os
+from livereload import Server
+
+
+def main():
+    port = 35729  # Default livereload port
+    if "--port" in sys.argv:
+        idx = sys.argv.index("--port")
+        if idx + 1 < len(sys.argv):
+            try:
+                port = int(sys.argv[idx + 1])
+            except ValueError:
+                pass
+    watch_dir = os.path.abspath(os.getcwd())
+    server = Server()
+    server.watch(watch_dir, delay=1)
+    print(
+        f"Starting livereload server on http://localhost:{port}, watching {watch_dir}"
+    )
+    server.serve(root=watch_dir, port=port, open_url_delay=None)
+
+
+if __name__ == "__main__":
+    main()

janito/rich_utils.py

@@ -2,42 +2,58 @@
 Utilities for working with the Rich library.
 """
 
-from rich.markdown import Markdown
-from rich.text import Text
 from rich.console import Console
+from typing import Optional
 
 
-def print_markdown(console: Console, message: str):
-    console.print(Markdown(message))
+class RichPrinter:
+    """
+    Utility class for printing styled messages using the Rich library.
 
+    Args:
+        console (Optional[Console]): An optional Rich Console instance. If not provided, a default Console will be created.
 
-def print_info(console: Console, message: str):
-    console.print(message, style="cyan", end="")
+    Methods:
+        print_info(message: str)
+            Print an informational message in cyan (no newline at end).
 
+        print_error(message: str)
+            Print an error message in bold red.
 
-def print_success(console: Console, message: str):
-    console.print(message, style="bold green", end="\n")
+        print_warning(message: str)
+            Print a warning message in bold yellow.
 
+        print_magenta(message: str)
+            Print a message in magenta.
+    """
 
-def print_error(console: Console, message: str):
-    console.print(message, style="bold red", end="\n")
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
 
+    def print_info(self, message: str):
+        self.console.print(message, style="cyan", end="")
 
-def print_warning(console: Console, message: str):
-    console.print(message, style="bold yellow", end="\n")
+    def print_error(self, message: str):
+        self.console.print(message, style="bold red", end="\n")
 
+    def print_warning(self, message: str):
+        self.console.print(message, style="bold yellow", end="\n")
 
-def print_magenta(console: Console, message: str):
-    console.print(message, style="magenta", end="\n")
+    def print_magenta(self, message: str):
+        self.console.print(message, style="magenta", end="\n")
 
-
-def print_stdout(console: Console, message: str):
-    console.print(
-        Text(message, style="on #003300", no_wrap=True, overflow=None), end=""
-    )
-
-
-def print_stderr(console: Console, message: str):
-    console.print(
-        Text(message, style="on #330000", no_wrap=True, overflow=None), end=""
-    )
+    def print_colored_message(self, message: str, color_index: int = 0):
+        """
+        Print a message with a cycling background color for verbose-messages.
+        """
+        bg_colors = [
+            "on blue",
+            "on green",
+            "on magenta",
+            "on cyan",
+            "on yellow",
+            "on red",
+            "on bright_black",
+        ]
+        style = f"bold white {bg_colors[color_index % len(bg_colors)]}"
+        self.console.print(message, style=style, end="\n")

janito/{cli_chat_shell → shell}/commands/__init__.py

@@ -1,55 +1,60 @@
-from .session import handle_continue, handle_history
+from .session import handle_history
 from .prompt import handle_prompt, handle_role
-from .session_control import handle_exit, handle_restart
+from .session_control import handle_exit
+from .conversation_restart import handle_restart
 from .utility import handle_help, handle_clear, handle_multi
+from .tools import handle_tools
 from .termweb_log import handle_termweb_log_tail, handle_termweb_status
-from .sum import handle_sum
-from .config import handle_reload
-from .history_start import handle_start
-from ..config_shell import handle_config_shell
+from .livelogs import handle_livelogs
+from .edit import handle_edit
+from .history_view import handle_view
+from janito.shell.session.config import handle_config_shell
 from .verbose import handle_verbose
 from .lang import handle_lang
 from janito.agent.runtime_config import runtime_config
+from .track import handle_track
 
 COMMAND_HANDLERS = {
     "/termweb-logs": handle_termweb_log_tail,
+    "/livelogs": handle_livelogs,
     "/termweb-status": handle_termweb_status,
+    "/edit": handle_edit,
     "/history": handle_history,
-    "/continue": handle_continue,
     "/exit": handle_exit,
     "exit": handle_exit,
     "/restart": handle_restart,
+    "/start": handle_restart,
     "/help": handle_help,
     "/multi": handle_multi,
     "/prompt": handle_prompt,
+    "/tools": handle_tools,
     "/verbose": handle_verbose,
 }
 
 if not runtime_config.get("vanilla_mode", False):
     COMMAND_HANDLERS["/role"] = handle_role
 
-
 COMMAND_HANDLERS["/lang"] = handle_lang
+COMMAND_HANDLERS["/track"] = handle_track
 
 COMMAND_HANDLERS.update(
     {
-        "/sum": handle_sum,
         "/clear": handle_clear,
-        "/start": handle_start,
+        "/restart": handle_restart,
         "/config": handle_config_shell,
-        "/reload": handle_reload,
+        "/view": handle_view,
     }
 )
 
 
-def handle_command(command, console, **kwargs):
+def handle_command(command, console, shell_state=None):
     parts = command.strip().split()
     cmd = parts[0]
     args = parts[1:]
     handler = COMMAND_HANDLERS.get(cmd)
     if handler:
-        # Pass args as a keyword argument for handlers that expect it
-        return handler(console, args=args, **kwargs)
+        # Pass shell_state and args as keyword arguments for handlers that expect them
+        return handler(console, args=args, shell_state=shell_state)
     console.print(
         f"[bold red]Invalid command: {cmd}. Type /help for a list of commands.[/bold red]"
     )

janito/{cli_chat_shell → shell}/commands/config.py

@@ -1,5 +1,5 @@
 def handle_reload(console, *args, **kwargs):
-    from ..load_prompt import load_prompt
+    from janito.shell.prompt.load_prompt import load_prompt
 
     agent = kwargs.get("agent")
     state = kwargs.get("state")
@@ -9,9 +9,9 @@ def handle_reload(console, *args, **kwargs):
         if hasattr(agent, "system_prompt_template"):
             agent.system_prompt_template = prompt_text
         # Update the first system message in the conversation if present
-        messages = state.get("messages") if state else None
-        if messages:
-            for msg in messages:
+        history = state.get("history") if state else None
+        if history:
+            for msg in history:
                 if msg.get("role") == "system":
                     msg["content"] = prompt_text
                     break

janito/shell/commands/conversation_restart.py

@@ -0,0 +1,74 @@
+import os
+
+from janito.shell.session.manager import reset_session_id
+
+
+def handle_restart(console, shell_state=None, **kwargs):
+    from janito.shell.session.manager import load_last_conversation, save_conversation
+
+    reset_session_id()
+    save_path = os.path.join(".janito", "last_conversation.json")
+
+    # --- Append end-of-conversation message to old history if it exists and is non-trivial ---
+    if os.path.exists(save_path):
+        try:
+            messages, prompts, usage = load_last_conversation(save_path)
+            if messages and (
+                len(messages) > 1
+                or (len(messages) == 1 and messages[0].get("role") != "system")
+            ):
+                messages.append(
+                    {"role": "system", "content": "[Session ended by user]"}
+                )
+                # Save to permanent chat history (let save_conversation pick session file)
+                save_conversation(messages, prompts, usage)
+        except Exception as e:
+            console.print(
+                f"[bold red]Failed to update previous conversation history:[/bold red] {e}"
+            )
+
+    # Clear the terminal screen
+    console.clear()
+
+    # Reset conversation history using its clear method
+    shell_state.conversation_history.clear()
+
+    # Reset tool use tracker
+    try:
+        from janito.agent.tool_use_tracker import ToolUseTracker
+
+        ToolUseTracker.instance().clear_history()
+    except Exception as e:
+        console.print(
+            f"[bold yellow]Warning: Failed to reset tool use tracker:[/bold yellow] {e}"
+        )
+    # Set system prompt from agent template if available
+    if (
+        hasattr(shell_state, "profile_manager")
+        and shell_state.profile_manager
+        and hasattr(shell_state.profile_manager, "agent")
+        and shell_state.profile_manager.agent
+        and getattr(shell_state.profile_manager.agent, "system_prompt_template", None)
+        and not any(
+            m.get("role") == "system"
+            for m in shell_state.conversation_history.get_messages()
+        )
+    ):
+        shell_state.conversation_history.set_system_message(
+            shell_state.profile_manager.agent.system_prompt_template
+        )
+
+    # Reset token usage info in-place so all references (including status bar) are updated
+    for k in ("prompt_tokens", "completion_tokens", "total_tokens"):
+        if k in shell_state.last_usage_info:
+            shell_state.last_usage_info[k] = 0
+        else:
+            shell_state.last_usage_info[k] = 0
+    shell_state.last_elapsed = None
+
+    console.print(
+        "[bold green]Conversation history has been started (context reset).[/bold green]"
+    )
+
+
+handle_restart.help_text = "Start a new conversation (reset context)"

janito/shell/commands/edit.py

@@ -0,0 +1,24 @@
+import os
+import webbrowser
+from janito.agent.runtime_config import runtime_config
+
+
+def handle_edit(console, args=None, shell_state=None, **kwargs):
+    if not args or len(args) < 1:
+        console.print("[red]Usage: /edit <filename>[/red]")
+        return
+    filename = args[0]
+    if not os.path.isfile(filename):
+        console.print(f"[red]File not found:[/red] {filename}")
+        return
+    port = getattr(shell_state, "termweb_port", None) or runtime_config.get(
+        "termweb_port", 8080
+    )
+    url = f"http://localhost:{port}/?path={filename}"
+    console.print(
+        f"[green]Opening in browser:[/green] [underline blue]{url}[/underline blue]"
+    )
+    webbrowser.open(url)
+
+
+handle_edit.help_text = "Open a file in the browser-based editor"

janito/shell/commands/history_view.py

@@ -0,0 +1,18 @@
+def handle_view(console, args=None, shell_state=None, **kwargs):
+    messages = shell_state.conversation_history.get_messages()
+    if not messages:
+        console.print("[yellow]Conversation history is empty.[/yellow]")
+        return
+    for i, msg in enumerate(messages, 1):
+        role = msg.get("role", "?")
+        content = msg.get("content", "")
+        tool_calls = msg.get("tool_calls")
+        tool_call_id = msg.get("tool_call_id")
+        console.print(f"[bold]{i}. {role}:[/bold] {content}")
+        if tool_calls:
+            console.print(f"   [cyan]tool_calls:[/cyan] {tool_calls}")
+        if tool_call_id:
+            console.print(f"   [magenta]tool_call_id:[/magenta] {tool_call_id}")
+
+
+handle_view.help_text = "Print the current LLM conversation history"

janito/{cli_chat_shell → shell}/commands/lang.py

@@ -14,3 +14,6 @@ def handle_lang(console, args=None, **kwargs):
     console.print(
         f"[bold green]Idioma alterado para:[/bold green] [cyan]{lang_code}[/cyan]"
     )
+
+
+handle_lang.help_text = "Change the interface language (e.g., /lang en)"

janito/shell/commands/livelogs.py

@@ -0,0 +1,42 @@
+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/{cli_chat_shell → shell}/commands/prompt.py

@@ -1,7 +1,7 @@
 from janito.agent.runtime_config import runtime_config
 
 
-def handle_prompt(console, **kwargs):
+def handle_prompt(console, shell_state=None, **kwargs):
     profile_manager = kwargs.get("profile_manager")
     prompt = profile_manager.system_prompt_template if profile_manager else None
     if not prompt and profile_manager:
@@ -9,9 +9,15 @@ def handle_prompt(console, **kwargs):
     console.print(f"[bold magenta]System Prompt:[/bold magenta]\n{prompt}")
 
 
-def handle_role(console, *args, **kwargs):
-    state = kwargs.get("state")
-    profile_manager = kwargs.get("profile_manager")
+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
@@ -20,7 +26,7 @@ def handle_role(console, *args, **kwargs):
         profile_manager.set_role(new_role)
     # Update system message in conversation
     found = False
-    for msg in state["messages"]:
+    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
@@ -28,7 +34,8 @@ def handle_role(console, *args, **kwargs):
             found = True
             break
     if not found:
-        state["messages"].insert(0, {"role": "system", "content": new_role})
+        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)
@@ -36,6 +43,9 @@ def handle_role(console, *args, **kwargs):
     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")

janito/shell/commands/session.py

@@ -0,0 +1,35 @@
+def handle_history(console, shell_state=None, *args, **kwargs):
+    if shell_state and hasattr(shell_state, "mem_history"):
+        input_history = list(shell_state.mem_history.get_strings())
+    else:
+        input_history = []
+    if not args:
+        # Default: last 5 inputs
+        start = max(0, len(input_history) - 5)
+        end = len(input_history)
+    elif len(args) == 1:
+        count = int(args[0])
+        start = max(0, len(input_history) - count)
+        end = len(input_history)
+    elif len(args) >= 2:
+        start = int(args[0])
+        end = int(args[1]) + 1  # inclusive
+    else:
+        start = 0
+        end = len(input_history)
+
+    console.print(
+        f"[bold cyan]Showing input history {start} to {end - 1} (total {len(input_history)}):[/bold cyan]"
+    )
+    for idx, line in enumerate(input_history[start:end], start=start):
+        console.print(f"{idx}: {line}")
+        if isinstance(line, dict):
+            role = line.get("role", "unknown")
+            content = line.get("content", "")
+        else:
+            role = "user"
+            content = line
+        console.print(f"[bold]{idx} [{role}]:[/bold] {content}")
+
+
+handle_history.help_text = "Show input history for this session"

janito/{cli_chat_shell → shell}/commands/session_control.py

@@ -6,9 +6,9 @@ import subprocess
 def restart_cli():
     # Clean up prompt_toolkit session if active
     try:
-        from janito.cli_chat_shell import chat_loop
+        from janito.shell import main
 
-        session = getattr(chat_loop, "active_prompt_session", None)
+        session = getattr(main, "active_prompt_session", None)
         if session is not None and hasattr(session, "app"):
             session.app.exit()
     except Exception:
@@ -42,6 +42,4 @@ def handle_exit(console, **kwargs):
     sys.exit(0)
 
 
-def handle_restart(console, **kwargs):
-    console.print("[bold yellow]Restarting CLI...[/bold yellow]")
-    restart_cli()
+handle_exit.help_text = "Exit chat mode"

janito/{cli_chat_shell → shell}/commands/termweb_log.py

@@ -14,12 +14,12 @@ def is_termweb_running(port):
         return False
 
 
-def handle_termweb_log_tail(console: Console, *args, state=None, **kwargs):
+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 = state.get("termweb_stdout_path") if state else None
-    stderr_path = state.get("termweb_stderr_path") if state else None
+    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]"
@@ -51,20 +51,23 @@ def handle_termweb_log_tail(console: Console, *args, state=None, **kwargs):
         console.print("[termweb] No output or errors captured in logs.")
 
 
-def handle_termweb_status(console: Console, *args, state=None, **kwargs):
-    if state is None:
+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 = state.get("termweb_port")
-    port_source = "state"
+    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 = state.get("termweb_pid")
-    stdout_path = state.get("termweb_stdout_path")
-    stderr_path = state.get("termweb_stderr_path")
+    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)
@@ -84,3 +87,8 @@ def handle_termweb_status(console: Console, *args, state=None, **kwargs):
         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"
+)