janito 1.6.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

janito/cli_chat_shell/chat_loop.py

@@ -4,34 +4,68 @@ from .chat_ui import setup_prompt_session, print_welcome_message
 from .commands import handle_command
 from janito.agent.conversation_exceptions import EmptyResponseError, ProviderError
 
-
-def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
+# Track the active prompt session for cleanup
+active_prompt_session = None
+
+
+def start_chat_shell(
+    profile_manager,
+    continue_session=False,
+    max_rounds=50,
+    termweb_stdout_path=None,
+    termweb_stderr_path=None,
+):
+    import janito.i18n as i18n
+    from janito.agent.runtime_config import runtime_config
+
+    i18n.set_locale(runtime_config.get("lang", "en"))
+    global active_prompt_session
     agent = profile_manager.agent
     message_handler = RichMessageHandler()
     console = message_handler.console
 
     # Load state
     state = load_chat_state(continue_session)
+    if termweb_stdout_path:
+        state["termweb_stdout_path"] = termweb_stdout_path
+    if termweb_stderr_path:
+        state["termweb_stderr_path"] = termweb_stderr_path
     messages = state["messages"]
     mem_history = state["mem_history"]
-    last_usage_info = state["last_usage_info"]
+    last_usage_info_ref = {"value": state["last_usage_info"]}
     last_elapsed = state["last_elapsed"]
 
-    # Add system prompt if needed
-    if profile_manager.system_prompt_template and not any(
-        m.get("role") == "system" for m in messages
+    # Add system prompt if needed (skip in vanilla mode)
+    from janito.agent.runtime_config import runtime_config
+
+    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 messages)
     ):
         messages.insert(0, {"role": "system", "content": agent.system_prompt_template})
 
     print_welcome_message(console, continued=continue_session)
 
     session = setup_prompt_session(
-        messages, last_usage_info, last_elapsed, mem_history, profile_manager, agent
+        messages, last_usage_info_ref, last_elapsed, mem_history, profile_manager, agent
     )
+    active_prompt_session = session
+
+    inject_message = state.get("inject_message")
+    if "inject_message" in state:
+        del state["inject_message"]
 
     while True:
         try:
-            if state.get("paste_mode"):
+            if inject_message is not None:
+                user_input = inject_message
+                inject_message = None
+                was_paste_mode = False
+            elif state.get("paste_mode"):
                 console.print("")
                 user_input = session.prompt("Multiline> ", multiline=True)
                 was_paste_mode = True
@@ -40,7 +74,7 @@ def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
                 from prompt_toolkit.formatted_text import HTML
 
                 user_input = session.prompt(
-                    HTML("<prompt>💬 </prompt>"), multiline=False
+                    HTML("<inputline>💬 </inputline>"), multiline=False
                 )
                 was_paste_mode = False
         except EOFError:
@@ -51,7 +85,10 @@ def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
             try:
                 confirm = (
                     session.prompt(
-                        HTML("<prompt>Do you really want to exit? (y/n): </prompt>")
+                        # Use <inputline> for full-line blue background, <prompt> for icon only
+                        HTML(
+                            "<inputline>Do you really want to exit? (y/n): </inputline>"
+                        )
                     )
                     .strip()
                     .lower()
@@ -95,8 +132,10 @@ def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
 
         start_time = time.time()
 
+        # No need to propagate verbose; ToolExecutor and others fetch from runtime_config
+
         try:
-            response = profile_manager.agent.handle_conversation(
+            response = profile_manager.agent.chat(
                 messages,
                 max_rounds=max_rounds,
                 message_handler=message_handler,
@@ -118,7 +157,7 @@ def start_chat_shell(profile_manager, continue_session=False, max_rounds=50):
         last_elapsed = time.time() - start_time
 
         usage = response.get("usage")
-        last_usage_info = usage
+        last_usage_info_ref["value"] = usage
 
         # Save conversation and input history
-        save_chat_state(messages, mem_history, last_usage_info)
+        save_chat_state(messages, mem_history, last_usage_info_ref["value"])

janito/cli_chat_shell/chat_state.py

@@ -9,7 +9,7 @@ from prompt_toolkit.history import InMemoryHistory
 
 def load_chat_state(continue_session: bool):
     messages = []
-    last_usage_info = None
+    last_usage_info = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
     last_elapsed = None
     history_list = load_input_history()
     mem_history = InMemoryHistory()

janito/cli_chat_shell/chat_ui.py

@@ -5,7 +5,7 @@ from janito.agent.runtime_config import runtime_config
 
 
 def setup_prompt_session(
-    messages, last_usage_info, last_elapsed, mem_history, profile_manager, agent
+    messages, last_usage_info_ref, last_elapsed, mem_history, profile_manager, agent
 ):
     model_name = getattr(agent, "model", None)
 
@@ -13,7 +13,7 @@ def setup_prompt_session(
         return messages
 
     def get_usage():
-        return last_usage_info
+        return last_usage_info_ref["value"]
 
     def get_elapsed():
         return last_elapsed
@@ -32,7 +32,6 @@ def setup_prompt_session(
                 )
                 else (runtime_config.get("role") or effective_config.get("role"))
             ),
-            style_ref=lambda: getattr(profile_manager, "interaction_style", "default"),
         ),
         mem_history,
     )

janito/cli_chat_shell/commands/__init__.py

@@ -1,13 +1,19 @@
 from .session import handle_continue, handle_history
-from .system import handle_system, handle_role, handle_style
+from .prompt import handle_prompt, handle_role
 from .session_control import handle_exit, handle_restart
 from .utility import handle_help, handle_clear, handle_multi
+from .termweb_log import handle_termweb_log_tail, handle_termweb_status
+from .sum import handle_sum
 from .config import handle_reload
-from .history_reset import handle_reset
+from .history_start import handle_start
 from ..config_shell import handle_config_shell
+from .verbose import handle_verbose
+from .lang import handle_lang
 from janito.agent.runtime_config import runtime_config
 
 COMMAND_HANDLERS = {
+    "/termweb-logs": handle_termweb_log_tail,
+    "/termweb-status": handle_termweb_status,
     "/history": handle_history,
     "/continue": handle_continue,
     "/exit": handle_exit,
@@ -15,19 +21,23 @@ COMMAND_HANDLERS = {
     "/restart": handle_restart,
     "/help": handle_help,
     "/multi": handle_multi,
-    "/system": handle_system,
+    "/prompt": handle_prompt,
+    "/verbose": handle_verbose,
 }
 
 if not runtime_config.get("vanilla_mode", False):
     COMMAND_HANDLERS["/role"] = handle_role
 
+
+COMMAND_HANDLERS["/lang"] = handle_lang
+
 COMMAND_HANDLERS.update(
     {
+        "/sum": handle_sum,
         "/clear": handle_clear,
-        "/reset": handle_reset,
+        "/start": handle_start,
         "/config": handle_config_shell,
         "/reload": handle_reload,
-        "/style": handle_style,
     }
 )
 
@@ -38,7 +48,8 @@ def handle_command(command, console, **kwargs):
     args = parts[1:]
     handler = COMMAND_HANDLERS.get(cmd)
     if handler:
-        return handler(console, *args, **kwargs)
+        # Pass args as a keyword argument for handlers that expect it
+        return handler(console, args=args, **kwargs)
     console.print(
         f"[bold red]Invalid command: {cmd}. Type /help for a list of commands.[/bold red]"
     )

janito/cli_chat_shell/commands/{history_reset.py → history_start.py}

@@ -2,14 +2,22 @@ from prompt_toolkit.history import InMemoryHistory
 import os
 
 
-def handle_reset(console, state, **kwargs):
+def handle_start(console, state, **kwargs):
+
     save_path = os.path.join(".janito", "last_conversation.json")
 
+    # Clear the terminal screen
+    os.system("cls" if os.name == "nt" else "clear")
+
     # Clear in-memory conversation and prompt history
     state["messages"].clear()
     state["history_list"].clear()
     state["mem_history"] = InMemoryHistory()
-    state["last_usage_info"] = None
+    state["last_usage_info"] = {
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "total_tokens": 0,
+    }
     state["last_elapsed"] = None
 
     # Delete saved conversation file if exists
@@ -23,7 +31,7 @@ def handle_reset(console, state, **kwargs):
             console.print(
                 f"[bold red]Failed to delete saved conversation:[/bold red] {e}"
             )
-    else:
-        console.print("[bold yellow]No saved conversation to delete.[/bold yellow]")
 
-    console.print("[bold green]Conversation history has been reset.[/bold green]")
+    console.print(
+        "[bold green]Conversation history has been started (context reset).[/bold green]"
+    )

janito/cli_chat_shell/commands/lang.py

@@ -0,0 +1,16 @@
+from janito.agent.runtime_config import runtime_config
+import janito.i18n as i18n
+
+
+def handle_lang(console, args=None, **kwargs):
+    if not args or len(args) == 0:
+        console.print(
+            "[bold yellow]Uso: /lang [código_idioma] (ex: pt, en, es)[/bold yellow]"
+        )
+        return
+    lang_code = args[0]
+    runtime_config.set("lang", lang_code)
+    i18n.set_locale(lang_code)
+    console.print(
+        f"[bold green]Idioma alterado para:[/bold green] [cyan]{lang_code}[/cyan]"
+    )

janito/cli_chat_shell/commands/prompt.py

@@ -0,0 +1,42 @@
+from janito.agent.runtime_config import runtime_config
+
+
+def handle_prompt(console, **kwargs):
+    profile_manager = kwargs.get("profile_manager")
+    prompt = profile_manager.system_prompt_template if profile_manager else None
+    if not prompt and profile_manager:
+        prompt = profile_manager.system_prompt_template
+    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")
+    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 state["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:
+        state["messages"].insert(0, {"role": "system", "content": 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}")
+
+
+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/cli_chat_shell/commands/session_control.py

@@ -1,5 +1,40 @@
 import os
 import sys
+import subprocess
+
+
+def restart_cli():
+    # Clean up prompt_toolkit session if active
+    try:
+        from janito.cli_chat_shell import chat_loop
+
+        session = getattr(chat_loop, "active_prompt_session", None)
+        if session is not None and hasattr(session, "app"):
+            session.app.exit()
+    except Exception:
+        pass  # Ignore cleanup errors
+
+    if os.name == "nt":
+        if (
+            "powershell" in os.environ.get("SHELL", "").lower()
+            or "pwsh" in sys.executable.lower()
+        ):
+            args = [
+                "powershell",
+                "-Command",
+                "Start-Process",
+                sys.executable,
+                "-ArgumentList",
+                "'-m','janito"
+                + ("','" + "','".join(sys.argv[1:]) if sys.argv[1:] else "")
+                + "'",
+            ]
+            subprocess.Popen(args)
+        else:
+            subprocess.Popen([sys.executable, "-m", "janito"] + sys.argv[1:])
+        sys.exit(0)
+    else:
+        os.execv(sys.executable, [sys.executable, "-m", "janito"] + sys.argv[1:])
 
 
 def handle_exit(console, **kwargs):
@@ -9,4 +44,4 @@ def handle_exit(console, **kwargs):
 
 def handle_restart(console, **kwargs):
     console.print("[bold yellow]Restarting CLI...[/bold yellow]")
-    os.execv(sys.executable, [sys.executable, "-m", "janito"] + sys.argv[1:])
+    restart_cli()

janito/cli_chat_shell/commands/sum.py

@@ -0,0 +1,49 @@
+def handle_sum(console, state, **kwargs):
+    """
+    Summarize the current chat history and replace it with a summary message.
+    """
+    agent = kwargs.get("agent")
+    if agent is None:
+        console.print("[bold red]Agent not provided to /sum command.[/bold red]")
+        return
+
+    messages = state.get("messages", [])
+    if not messages or len(messages) < 2:
+        console.print(
+            "[bold yellow]Not enough conversation to summarize.[/bold yellow]"
+        )
+        return
+
+    # Find the system message if present
+    system_msg = next((m for m in messages if m.get("role") == "system"), None)
+
+    # Prepare summary prompt
+    summary_prompt = {
+        "role": "user",
+        "content": "Summarize the following conversation in a concise paragraph for context. Only output the summary, do not include any tool calls or formatting.",
+    }
+    # Exclude system messages for the summary context
+    convo_for_summary = [m for m in messages if m.get("role") != "system"]
+    summary_messages = [summary_prompt] + convo_for_summary
+
+    try:
+        summary_response = agent.chat(summary_messages, spinner=True, max_tokens=256)
+        summary_text = (
+            summary_response["content"]
+            if isinstance(summary_response, dict)
+            else str(summary_response)
+        )
+    except Exception as e:
+        console.print(f"[bold red]Error during summarization: {e}[/bold red]")
+        return
+
+    # Rebuild conversation history
+    new_history = []
+    if system_msg:
+        new_history.append(system_msg)
+    new_history.append({"role": "assistant", "content": summary_text})
+    state["messages"] = new_history
+
+    console.print(
+        "[bold green]Conversation summarized and history replaced with summary.[/bold green]"
+    )

janito/cli_chat_shell/commands/termweb_log.py

@@ -0,0 +1,86 @@
+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, 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
+    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.")
+
+
+def handle_termweb_status(console: Console, *args, state=None, **kwargs):
+    if state is None:
+        console.print(
+            "[red]No shell state available. Cannot determine termweb status.[/red]"
+        )
+        return
+    port = state.get("termweb_port")
+    port_source = "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")
+    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}")

janito/cli_chat_shell/commands/utility.py

@@ -6,12 +6,15 @@ def handle_help(console, **kwargs):
   /restart  - Restart the CLI
   /help     - Show this help message
   /continue - Restore last saved conversation
-  /reset    - Reset conversation history
-  /system   - Show the system prompt
+  /start    - Reset conversation history
+  /prompt   - Show the system prompt
   /role     - Change the system role
   /clear    - Clear the terminal screen
   /multi    - Provide multiline input as next message
   /config   - Show or set configuration (see: /config show, /config set local|global key=value)
+  /termweb-logs - Show the last lines of the latest termweb logs
+  /termweb-status - Show status information about the running termweb server
+  /verbose [on|off] - Show or set verbose mode for this session
 """
     )
 

janito/cli_chat_shell/commands/verbose.py

@@ -0,0 +1,29 @@
+from janito.agent.runtime_config import runtime_config
+
+
+def handle_verbose(console, state, **kwargs):
+    """
+    /verbose [on|off]
+    Shows or sets verbose mode for the current shell session.
+    """
+    args = kwargs.get("args", [])
+    verbose = runtime_config.get("verbose", False)
+    if not args:
+        status = "ON" if verbose else "OFF"
+        console.print(
+            f"[bold green]/verbose:[/bold green] Verbose mode is currently [bold]{status}[/bold]."
+        )
+        return
+    arg = args[0].lower()
+    if arg == "on":
+        runtime_config["verbose"] = True
+        console.print(
+            "[bold green]/verbose:[/bold green] Verbose mode is now [bold]ON[/bold]."
+        )
+    elif arg == "off":
+        runtime_config["verbose"] = False
+        console.print(
+            "[bold green]/verbose:[/bold green] Verbose mode is now [bold]OFF[/bold]."
+        )
+    else:
+        console.print("[bold red]Usage:[/bold red] /verbose [on|off]")

janito/cli_chat_shell/load_prompt.py

@@ -1,18 +1,57 @@
 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:
-        # Default prompt file path (can be customized)
-        filename = os.path.join(
-            os.path.dirname(__file__), "../agent/templates/system_prompt_template.j2"
+        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}"
         )
-    filename = os.path.abspath(filename)
-    if not os.path.exists(filename):
-        raise FileNotFoundError(f"Prompt file not found: {filename}")
-    with open(filename, "r", encoding="utf-8") as f:
-        return f.read()

janito/cli_chat_shell/session_manager.py

@@ -27,8 +27,16 @@ def save_conversation(
 ):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     data = {"messages": messages, "prompts": prompts, "last_usage_info": usage_info}
+
+    def usage_serializer(obj):
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        return str(obj)
+
     with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2)
+        json.dump(data, f, indent=2, default=usage_serializer)
 
 
 def load_input_history():

janito/cli_chat_shell/shell_command_completer.py

@@ -0,0 +1,20 @@
+from prompt_toolkit.completion import Completer, Completion
+
+
+class ShellCommandCompleter(Completer):
+    def __init__(self):
+        # Import here to avoid circular import at module level
+        from janito.cli_chat_shell.commands import COMMAND_HANDLERS
+
+        # Only commands starting with '/'
+        self.commands = sorted(
+            [cmd for cmd in COMMAND_HANDLERS.keys() if cmd.startswith("/")]
+        )
+
+    def get_completions(self, document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith("/"):
+            prefix = text[1:]
+            for cmd in self.commands:
+                if cmd[1:].startswith(prefix):
+                    yield Completion(cmd, start_position=-(len(prefix) + 1))