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

janito/{shell → cli/chat_mode/shell}/commands/conversation_restart.py

@@ -1,10 +1,14 @@
 import os
+from janito.cli.chat_mode.shell.session.manager import reset_session_id
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
 
-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
+def handle_restart(shell_state=None):
+    from janito.cli.chat_mode.shell.session.manager import (
+        load_last_conversation,
+        save_conversation,
+    )
 
     reset_session_id()
     save_path = os.path.join(".janito", "last_conversation.json")
@@ -23,52 +27,52 @@ def handle_restart(console, shell_state=None, **kwargs):
                 # Save to permanent chat history (let save_conversation pick session file)
                 save_conversation(messages, prompts, usage)
         except Exception as e:
-            console.print(
+            shared_console.print(
                 f"[bold red]Failed to update previous conversation history:[/bold red] {e}"
             )
 
     # Clear the terminal screen
-    console.clear()
+    shared_console.clear()
 
-    # Reset conversation history using its clear method
-    shell_state.conversation_history.clear()
+    # Reset conversation history using the agent's method
+    if hasattr(shell_state, "agent") and shell_state.agent:
+        shell_state.agent.reset_conversation_history()
 
     # Reset tool use tracker
     try:
-        from janito.agent.tool_use_tracker import ToolUseTracker
+        from janito.tools.tool_use_tracker import ToolUseTracker
 
         ToolUseTracker.instance().clear_history()
     except Exception as e:
-        console.print(
+        shared_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_usage_info[k] = 0
     shell_state.last_elapsed = None
 
-    console.print(
+    # Reset the performance collector's last usage (so toolbar immediately reflects cleared stats)
+    try:
+        from janito.perf_singleton import performance_collector
+
+        performance_collector.reset_last_request_usage()
+    except Exception as e:
+        shared_console.print(
+            f"[bold yellow]Warning: Failed to reset PerformanceCollector token info:[/bold yellow] {e}"
+        )
+
+    shared_console.print(
         "[bold green]Conversation history has been started (context reset).[/bold green]"
     )
 
 
 handle_restart.help_text = "Start a new conversation (reset context)"
+
+
+class RestartShellHandler(ShellCmdHandler):
+    help_text = "Start a new conversation (reset context)"
+
+    def run(self):
+        handle_restart(self.shell_state)

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

@@ -0,0 +1,25 @@
+import os
+import webbrowser
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class EditShellHandler(ShellCmdHandler):
+    help_text = "Open a file in the browser-based editor"
+
+    def run(self):
+        filename = self.after_cmd_line.strip()
+        if not filename:
+            shared_console.print("[red]Usage: /edit <filename>[/red]")
+            return
+        if not os.path.isfile(filename):
+            shared_console.print(f"[red]File not found:[/red] {filename}")
+            return
+        from janito.cli.config import get_termweb_port
+
+        port = get_termweb_port()
+        url = f"http://localhost:{port}/?path={filename}"
+        shared_console.print(
+            f"[green]Opening in browser:[/green] [underline blue]{url}[/underline blue]"
+        )
+        webbrowser.open(url)

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

@@ -0,0 +1,16 @@
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class HelpShellHandler(ShellCmdHandler):
+    help_text = "Show this help message"
+
+    def run(self):
+        from . import (
+            COMMAND_HANDLERS,
+        )  # Import moved inside method to avoid circular import
+
+        shared_console.print("[bold magenta]Available commands:[/bold magenta]")
+        for cmd, handler_cls in sorted(COMMAND_HANDLERS.items()):
+            help_text = getattr(handler_cls, "help_text", "")
+            shared_console.print(f"[cyan]{cmd}[/cyan]: {help_text}")

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

@@ -0,0 +1,93 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+import json
+
+TRIM_LENGTH = 200  # Max chars to show for args or outputs before trimming
+
+
+def trim_value(val, trim_length=TRIM_LENGTH):
+    s = (
+        json.dumps(val, ensure_ascii=False)
+        if isinstance(val, (dict, list))
+        else str(val)
+    )
+    if len(s) > trim_length:
+        return s[:trim_length] + "... [trimmed]"
+    return s
+
+
+class ViewShellHandler(ShellCmdHandler):
+    help_text = "Print the current LLM conversation history"
+
+    def run(self):
+        if not hasattr(self.shell_state, "agent") or self.shell_state.agent is None:
+            shared_console.print("[red]No agent found in shell state.[/red]")
+            return
+        conversation_history = self.shell_state.agent.conversation_history
+        messages = conversation_history.get_history()
+        if not messages:
+            shared_console.print("[yellow]Conversation history is empty.[/yellow]")
+            return
+        for i, msg in enumerate(messages, 1):
+            self._print_message(i, msg)
+
+    def _print_message(self, i, msg):
+        role = msg.get("role", "?")
+        content = msg.get("content", "")
+        metadata = msg.get("metadata")
+        is_tool_result = (
+            role == "function"
+            and isinstance(metadata, dict)
+            and metadata.get("is_tool_result")
+        )
+        is_tool_call = (
+            role == "tool_call"
+            or (
+                isinstance(metadata, dict)
+                and (
+                    metadata.get("type") == "tool_call" or metadata.get("is_tool_call")
+                )
+            )
+        ) and not is_tool_result
+        if is_tool_call:
+            self._print_tool_call(i, metadata, content)
+        elif is_tool_result:
+            self._print_tool_result(i, content)
+        else:
+            self._print_regular_message(i, role, content, metadata)
+
+    def _print_tool_call(self, i, metadata, content):
+        func_name = None
+        args = None
+        if isinstance(metadata, dict):
+            tool_call = metadata.get("tool_call")
+            if tool_call and isinstance(tool_call, dict):
+                func_name = (
+                    tool_call.get("function") or tool_call.get("name") or "<unknown>"
+                )
+                args = tool_call.get("arguments") or tool_call.get("args") or {}
+            else:
+                func_name = metadata.get("name") or "<unknown>"
+                args = metadata.get("arguments") or metadata.get("args") or content
+        else:
+            func_name = "<unknown>"
+            args = content
+        trimmed_args = trim_value(args)
+        shared_console.print(
+            f"[bold]{i}. TOOL_CALL:[/bold] {func_name}({trimmed_args})"
+        )
+
+    def _print_tool_result(self, i, content):
+        trimmed_output = trim_value(content)
+        if "\n" in trimmed_output:
+            shared_console.print(f"[bold]{i}. TOOL_RESULT:[/bold]")
+            for line in trimmed_output.splitlines():
+                shared_console.print(line)
+        else:
+            shared_console.print(f"[bold]{i}. TOOL_RESULT:[/bold] {trimmed_output}")
+
+    def _print_regular_message(self, i, role, content, metadata):
+        trimmed_content = trim_value(content)
+        shared_console.print(f"[bold]{i}. {role}:[/bold] {trimmed_content}")
+        if metadata:
+            shared_console.print(f"   [cyan]metadata:[/cyan] {metadata}")

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

@@ -0,0 +1,25 @@
+from janito.cli.config import config
+import janito.i18n as i18n
+
+
+from janito.cli.config import config
+import janito.i18n as i18n
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class LangShellHandler(ShellCmdHandler):
+    help_text = "Change the interface language (e.g., /lang en)"
+
+    def run(self):
+        lang_code = self.after_cmd_line.strip()
+        if not lang_code:
+            shared_console.print(
+                "[bold yellow]Uso: /lang [código_idioma] (ex: pt, en, es)[/bold yellow]"
+            )
+            return
+        config.runtime_set("lang", lang_code)
+        i18n.set_locale(lang_code)
+        shared_console.print(
+            f"[bold green]Idioma alterado para:[/bold green] [cyan]{lang_code}[/cyan]"
+        )

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

@@ -0,0 +1,137 @@
+from janito.performance_collector import PerformanceCollector
+from rich.tree import Tree
+from rich.console import Console
+from rich import print as rprint
+import datetime
+
+# TODO: Replace this with your actual collector instance retrieval
+# For example, if you have a global or singleton:
+# from janito.app_context import performance_collector as collector
+from janito.perf_singleton import performance_collector as collector
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+def _event_timestamp(event):
+    if hasattr(event, "timestamp"):
+        try:
+            ts = float(getattr(event, "timestamp", 0))
+            return f" [dim]{datetime.datetime.fromtimestamp(ts)}[/dim]"
+        except Exception:
+            return ""
+    return ""
+
+
+def _event_tool_name(event):
+    return (
+        f" [cyan]{getattr(event, 'tool_name', '')}[/cyan]"
+        if hasattr(event, "tool_name")
+        else ""
+    )
+
+
+def _event_params(event):
+    return (
+        f" Params: {getattr(event, 'params', '')}" if hasattr(event, "params") else ""
+    )
+
+
+def _event_result(event):
+    return (
+        f" Result: {getattr(event, 'result', '')}" if hasattr(event, "result") else ""
+    )
+
+
+def _event_error(event):
+    return (
+        f" [red]Error: {getattr(event, 'error')}[/red]"
+        if hasattr(event, "error") and getattr(event, "error", None)
+        else ""
+    )
+
+
+def _event_message(event):
+    return (
+        f" [yellow]Message: {getattr(event, 'message')}[/yellow]"
+        if hasattr(event, "message")
+        else ""
+    )
+
+
+def _event_subtype(event):
+    return (
+        f" [magenta]Subtype: {getattr(event, 'subtype')}[/magenta]"
+        if hasattr(event, "subtype")
+        else ""
+    )
+
+
+def _event_status(event):
+    return (
+        f" [blue]Status: {getattr(event, 'status')}[/blue]"
+        if hasattr(event, "status")
+        else ""
+    )
+
+
+def _event_duration(event):
+    return (
+        f" [green]Duration: {getattr(event, 'duration')}[/green]"
+        if hasattr(event, "duration")
+        else ""
+    )
+
+
+def format_event(event_tuple, parent_tree=None):
+    event_type, event = event_tuple
+    desc = f"[bold]{event_type}[/bold]"
+    # Modular logic for each possible component
+    desc += _event_timestamp(event)
+    desc += _event_tool_name(event)
+    desc += _event_params(event)
+    desc += _event_result(event)
+    desc += _event_error(event)
+    desc += _event_message(event)
+    desc += _event_subtype(event)
+    desc += _event_status(event)
+    desc += _event_duration(event)
+    if parent_tree is not None:
+        node = parent_tree.add(desc)
+    else:
+        node = Tree(desc)
+    return node
+
+
+def drill_down_last_generation():
+    events = collector.get_all_events()
+    # Find the last RequestStarted
+    last_gen_start = None
+    for i in range(len(events) - 1, -1, -1):
+        if events[i][0] == "RequestStarted":
+            last_gen_start = i
+            break
+    if last_gen_start is None:
+        rprint("[red]No generations found.[/red]")
+        return
+    # Find the next GenerationFinished after last_gen_start
+    for j in range(last_gen_start + 1, len(events)):
+        if events[j][0] == "GenerationFinished":
+            last_gen_end = j
+            break
+    else:
+        last_gen_end = len(events) - 1
+    gen_events = events[last_gen_start : last_gen_end + 1]
+    tree = Tree("[bold green]Last Generation Details[/bold green]")
+    for evt in gen_events:
+        format_event(evt, tree)
+    console = Console()
+    console.print(tree)
+
+
+class LastShellHandler(ShellCmdHandler):
+    help_text = (
+        "Show details of the last generation, with drill-down of tool executions."
+    )
+
+    def run(self):
+        drill_down_last_generation()

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

@@ -0,0 +1,49 @@
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class LivelogsShellHandler(ShellCmdHandler):
+    help_text = "Show the last lines of livereload logs. Usage: /livelogs [lines]"
+
+    def run(self):
+        lines_arg = self.after_cmd_line.strip()
+        lines = 20
+        if lines_arg and lines_arg.isdigit():
+            lines = int(lines_arg)
+        stdout_path = self.shell_state.termweb_stdout_path if self.shell_state else None
+        stderr_path = (
+            self.shell_state.livereload_stderr_path if self.shell_state else None
+        )
+        if not stdout_path and not stderr_path:
+            shared_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:
+                    shared_console.print(
+                        f"[yellow][livereload][stdout] Tail of {stdout_path}:\n"
+                        + "".join(stdout_lines)
+                    )
+            except Exception as e:
+                shared_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:
+                    shared_console.print(
+                        f"[red][livereload][stderr] Tail of {stderr_path}:\n"
+                        + "".join(stderr_lines)
+                    )
+            except Exception as e:
+                shared_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
+        ):
+            shared_console.print("[livereload] No output or errors captured in logs.")

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

@@ -0,0 +1,51 @@
+from prompt_toolkit.shortcuts import prompt
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.document import Document
+from prompt_toolkit.key_binding import KeyBindings
+from janito.cli.console import shared_console
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class MultiShellHandler(ShellCmdHandler):
+    help_text = "Prompt for multi-line input and display the result. Usage: /multi"
+
+    def run(self):
+        shared_console.print(
+            "[bold blue]Entering multi-line input mode. Press Esc+Enter or Ctrl+D to submit, Ctrl+C to cancel.[/bold blue]"
+        )
+        # Prompt for multi-line input
+        bindings = KeyBindings()
+        submitted = {"value": None}
+
+        @bindings.add("escape", "enter")
+        def _(event):
+            buffer = event.app.current_buffer
+            submitted["value"] = buffer.text
+            event.app.exit(result=buffer.text)
+
+        # Support Ctrl+D
+        @bindings.add("c-d")
+        def _(event):
+            buffer = event.app.current_buffer
+            submitted["value"] = buffer.text
+            event.app.exit(result=buffer.text)
+
+        try:
+            user_input = prompt(
+                "Multi-line > ",
+                multiline=True,
+                key_bindings=bindings,
+            )
+        except (EOFError, KeyboardInterrupt):
+            shared_console.print("[red]Multi-line input cancelled.[/red]")
+            return
+
+        # Save input to history if available
+        user_input_history = getattr(self.shell_state, "user_input_history", None)
+        if user_input_history is not None:
+            user_input_history.append(user_input)
+        # Store input for main chat loop to consume as if just entered by the user
+        self.shell_state.injected_input = user_input
+        shared_console.print(
+            "[green]Multi-line input will be sent as your next chat prompt.[/green]"
+        )

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

@@ -0,0 +1,64 @@
+from janito.cli.config import config
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class PromptShellHandler(ShellCmdHandler):
+    help_text = "Show the system prompt"
+
+    def run(self):
+        agent = getattr(self.shell_state, "agent", None)
+        if agent and hasattr(agent, "get_system_prompt"):
+            prompt = agent.get_system_prompt()
+            shared_console.print(
+                f"[bold magenta]System Prompt:[/bold magenta]\n{prompt}"
+            )
+        else:
+            shared_console.print(
+                "[bold red]No LLM agent available to fetch the system prompt.[/bold red]"
+            )
+
+
+class RoleShellHandler(ShellCmdHandler):
+    help_text = "Change the system role"
+
+    def run(self):
+        new_role = self.after_cmd_line.strip()
+        if not new_role:
+            agent = getattr(self.shell_state, "agent", None)
+            if agent and hasattr(agent, "template_vars"):
+                current_role = agent.template_vars.get("role", None)
+            else:
+                current_role = None
+            if not current_role:
+                current_role = "<not set>"
+            shared_console.print(
+                f"[bold green]Current system role:[/bold green] {current_role}"
+            )
+            return
+
+        agent = getattr(self.shell_state, "agent", None)
+        if agent and hasattr(agent, "set_template_var"):
+            agent.set_template_var("role", new_role)
+            # Refresh the system prompt with the new role if possible
+            if (
+                hasattr(agent, "set_system_using_template")
+                and hasattr(agent, "_system_prompt_template_file")
+                and agent._system_prompt_template_file
+            ):
+                agent.set_system_using_template(
+                    agent._system_prompt_template_file, **agent.template_vars
+                )
+        shared_console.print(
+            f"[bold green]System role updated to:[/bold green] {new_role}"
+        )
+
+
+class ProfileShellHandler(ShellCmdHandler):
+    help_text = (
+        "Show the current and available Agent Profile (only 'base' is supported)"
+    )
+
+    def run(self):
+        shared_console.print("[bold green]Current profile:[/bold green] base")
+        shared_console.print("[bold yellow]Available profiles:[/bold yellow]\n- base")

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

@@ -0,0 +1,36 @@
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+
+
+class RoleCommandShellHandler(ShellCmdHandler):
+    """Set or display the current role."""
+
+    def __init__(self, shell_state, handler):
+        super().__init__(shell_state, handler)
+        self.name = "role"
+        self.description = "Set or display the current role"
+        self.usage = "role [new_role]"
+
+    def execute(self, args):
+        if not args:
+            # Display current role
+            current_role = self.handler.agent.template_vars.get("role", "default")
+            return f"Current role: {current_role}"
+        else:
+            # Set new role
+            new_role = " ".join(args)
+            self.handler.agent.template_vars["role"] = new_role
+            # Refresh the system prompt with the new role if possible
+            if (
+                hasattr(self.handler.agent, "set_system_using_template")
+                and hasattr(self.handler.agent, "_system_prompt_template_file")
+                and self.handler.agent._system_prompt_template_file
+            ):
+                self.handler.agent.set_system_using_template(
+                    self.handler.agent._system_prompt_template_file,
+                    **self.handler.agent.template_vars,
+                )
+            return f"Role set to: {new_role}"
+
+    def get_completions(self, document, complete_event):
+        # No completions for this command
+        return []

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

@@ -0,0 +1,40 @@
+from janito.cli.console import shared_console
+
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class HistoryShellHandler(ShellCmdHandler):
+    help_text = "Show input history for this session"
+
+    def run(self):
+        if self.shell_state and hasattr(self.shell_state, "mem_history"):
+            input_history = list(self.shell_state.mem_history.get_strings())
+        else:
+            input_history = []
+        args = self.after_cmd_line.strip().split()
+        if not args:
+            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
+        else:
+            start = 0
+            end = len(input_history)
+        shared_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):
+            shared_console.print(f"{idx}: {line}")
+            if isinstance(line, dict):
+                role = line.get("role", "unknown")
+                content = line.get("content", "")
+            else:
+                role = "user"
+                content = line
+            shared_console.print(f"[bold]{idx} [{role}]:[/bold] {content}")

janito/{shell → cli/chat_mode/shell}/commands/session_control.py

@@ -6,7 +6,7 @@ import subprocess
 def restart_cli():
     # Clean up prompt_toolkit session if active
     try:
-        from janito.shell import main
+        from janito.cli.chat_mode import chat_mode as main
 
         session = getattr(main, "active_prompt_session", None)
         if session is not None and hasattr(session, "app"):
@@ -37,7 +37,7 @@ def restart_cli():
         os.execv(sys.executable, [sys.executable, "-m", "janito"] + sys.argv[1:])
 
 
-def handle_exit(console, **kwargs):
+def handle_exit(**kwargs):
     console.print("[bold red]Exiting chat mode.[/bold red]")
     sys.exit(0)