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

janito/cli/main.py

@@ -3,8 +3,9 @@
 from janito.cli.arg_parser import create_parser
 from janito.cli.config_commands import handle_config_commands
 from janito.cli.logging_setup import setup_verbose_logging
-from janito.cli.runner.cli_main import run_cli
+from janito.cli.cli_main import run_cli
 from janito.agent.runtime_config import unified_config
+from janito.cli.livereload_starter import start_livereload
 
 # Ensure all tools are registered at startup
 import janito.agent.tools  # noqa: F401
@@ -25,6 +26,77 @@ def main():
     parser = create_parser()
     args = parser.parse_args()
 
+    # Handle --set-provider-config <name> <key> <value>
+    if getattr(args, "set_provider_config", None) is not None:
+        import os
+        import json
+
+        name, key, value = args.set_provider_config
+        config_dir = os.path.expanduser("~/.janito")
+        os.makedirs(config_dir, exist_ok=True)
+        providers_path = os.path.join(config_dir, "providers.json")
+
+        # Load or initialize providers config
+        if os.path.exists(providers_path):
+            with open(providers_path, "r", encoding="utf-8") as f:
+                try:
+                    providers = json.load(f)
+                except Exception:
+                    providers = {}
+        else:
+            providers = {}
+
+        if name not in providers or not isinstance(providers[name], dict):
+            providers[name] = {}
+        providers[name][key] = value
+
+        with open(providers_path, "w", encoding="utf-8") as f:
+            json.dump(providers, f, indent=2)
+
+        print(f"Set {key} for provider '{name}' in {providers_path}.")
+        sys.exit(0)
+
+    # Handle --list [n] before anything else
+    if getattr(args, "list", None) is not None:
+        import os
+        import glob
+
+        n = args.list if args.list is not None else 10
+        history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
+        if not os.path.exists(history_dir):
+            print("No session history found.")
+            sys.exit(0)
+        files = glob.glob(os.path.join(history_dir, "*.json"))
+        files = sorted(files, key=os.path.getmtime, reverse=True)
+        print(f"Last {n} sessions:")
+        for f in files[:n]:
+            session_id = os.path.splitext(os.path.basename(f))[0]
+            print(session_id)
+        sys.exit(0)
+
+    # Handle --view <id> to print conversation history
+    if getattr(args, "view", None) is not None:
+        import os
+        import json
+
+        history_dir = os.path.join(os.path.expanduser(".janito"), "chat_history")
+        session_file = os.path.join(history_dir, f"{args.view}.json")
+        if not os.path.exists(session_file):
+            print(f"Session '{args.view}' not found.")
+            sys.exit(1)
+        with open(session_file, "r", encoding="utf-8") as f:
+            try:
+                messages = json.load(f)
+            except Exception as e:
+                print(f"Failed to load session: {e}")
+                sys.exit(1)
+        print(f"Conversation history for session '{args.view}':\n")
+        for i, msg in enumerate(messages, 1):
+            role = msg.get("role", "?")
+            content = msg.get("content", "")
+            print(f"[{i}] {role}: {content}\n")
+        sys.exit(0)
+
     # Seleção de idioma: prioridade --lang > config.json > padrão
     lang = getattr(args, "lang", None) or unified_config.get("lang", None) or "en"
     runtime_config.set("lang", lang)
@@ -72,37 +144,31 @@ def main():
         sys.exit(0)
 
     if getattr(args, "info", False):
-        # (mantém bloco info)
-
-        print("Janito - Agente CLI de automação")
-        print(f"Modelo: {unified_config.get('model')}")
-        print(f"Temperatura: {unified_config.get('temperature')}")
-        print(f"Max tokens: {unified_config.get('max_tokens')}")
-        # System prompt real via AgentProfileManager
-        # Prioridade: --system-file > --system > AgentProfileManager
+        # Compact, colored, single-line info output using rich
+        from janito import __version__
+        from rich.console import Console
+        from rich.text import Text
         from janito.agent.runtime_config import runtime_config
 
+        model = unified_config.get("model")
+        temperature = unified_config.get("temperature")
+        max_tokens = unified_config.get("max_tokens")
         system_prompt_val = None
-        origem = None
         if getattr(args, "system_file", None):
             try:
                 with open(args.system_file, "r", encoding="utf-8") as f:
                     system_prompt_val = f.read().strip()
                 runtime_config.set("system_prompt_template", system_prompt_val)
-                origem = "--system-file"
             except Exception as e:
-                print(f"System prompt: (error reading system-file: {e})")
+                system_prompt_val = f"(error reading system-file: {e})"
         elif getattr(args, "system", None):
             system_prompt_val = args.system
             runtime_config.set("system_prompt_template", system_prompt_val)
-            origem = "--system"
         else:
             system_prompt_val = runtime_config.get("system_prompt_template")
-            if system_prompt_val:
-                origem = "runtime_config"
-        if system_prompt_val:
-            print(f"System prompt ({origem or 'runtime_config'}): {system_prompt_val}")
-        else:
+            # if system_prompt_val:
+            #     origem = "runtime_config"
+        if not system_prompt_val:
             try:
                 from janito.agent.profile_manager import AgentProfileManager
                 from janito.agent.config import get_api_key
@@ -119,10 +185,22 @@ def main():
                 system_prompt_val = profile_manager.get_system_prompt(
                     role, interaction_mode, profile
                 )
-                print(f"System prompt (profile_manager): {system_prompt_val}")
             except Exception as e:
-                print(f"System prompt: (error obtaining from profile_manager: {e})")
-        sys.exit(0)
+                system_prompt_val = f"(error: {e})"
+
+        console = Console()
+        info_text = Text()
+        info_text.append(f"Janito v{__version__}", style="bold cyan")
+        info_text.append(" | model: ", style="white")
+        info_text.append(str(model), style="green")
+        info_text.append(" | temp: ", style="white")
+        info_text.append(str(temperature), style="yellow")
+        info_text.append(" | max_tokens: ", style="white")
+        info_text.append(str(max_tokens), style="magenta")
+        info_text.append(" | system: ", style="white")
+        info_text.append(str(system_prompt_val), style="bold blue")
+        console.print(info_text, style="dim")
+        # Previously: sys.exit(0) would exit after showing info. Now, program continues after displaying info.
 
     # ... resto do main ...
     handle_config_commands(args)
@@ -131,5 +209,16 @@ def main():
         import subprocess  # Only needed if launching web
 
         subprocess.run([sys.executable, "-m", "janito.web"])
+    elif getattr(args, "live", False):
+        port = 35729  # Default livereload port
+        livereload_proc, started, livereload_stdout_path, livereload_stderr_path = (
+            start_livereload(port)
+        )
+        try:
+            run_cli(args)
+        finally:
+            if livereload_proc:
+                livereload_proc.terminate()
+                livereload_proc.wait()
     else:
         run_cli(args)

janito/cli/one_shot.py

@@ -0,0 +1,66 @@
+from janito.agent.conversation_exceptions import (
+    MaxRoundsExceededError,
+    ProviderError,
+    EmptyResponseError,
+)
+
+
+def run_oneshot_mode(args, profile_manager, runtime_config):
+    prompt = getattr(args, "input_arg", None)
+    from rich.console import Console
+    from janito.agent.rich_message_handler import RichMessageHandler
+
+    console = Console()
+    message_handler = RichMessageHandler()
+    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})
+    import time
+
+    info_start_time = None
+    if getattr(args, "info", False):
+        info_start_time = time.time()
+    try:
+        max_rounds = 100
+        from janito.agent.conversation_history import ConversationHistory
+
+        result = profile_manager.agent.chat(
+            ConversationHistory(messages),
+            message_handler=message_handler,
+            spinner=True,
+            max_rounds=max_rounds,
+            stream=getattr(args, "stream", False),
+        )
+        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",
+            )
+    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}")

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/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,23 +2,13 @@
 Utilities for working with the Rich library.
 """
 
-from rich.markdown import Markdown
-from rich.text import Text
 from rich.console import Console
 
 
-def print_markdown(console: Console, message: str):
-    console.print(Markdown(message))
-
-
 def print_info(console: Console, message: str):
     console.print(message, style="cyan", end="")
 
 
-def print_success(console: Console, message: str):
-    console.print(message, style="bold green", end="\n")
-
-
 def print_error(console: Console, message: str):
     console.print(message, style="bold red", end="\n")
 
@@ -29,15 +19,3 @@ def print_warning(console: Console, message: str):
 
 def print_magenta(console: Console, message: str):
     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=""
-    )

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

@@ -1,27 +1,34 @@
-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 .livelogs import handle_livelogs
 from .sum import handle_sum
-from .config import handle_reload
-from .history_start import handle_start
-from ..config_shell import handle_config_shell
+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
 
 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,
 }
 
@@ -35,21 +42,21 @@ 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,72 @@
+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]"
+    )

janito/shell/commands/edit.py

@@ -0,0 +1,21 @@
+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)

janito/shell/commands/history_view.py

@@ -0,0 +1,18 @@
+def handle_view(console, args=None, shell_state=None, **kwargs):
+    """
+    Prints the current LLM conversation history in a readable format.
+    """
+    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}")

janito/shell/commands/livelogs.py

@@ -0,0 +1,40 @@
+def handle_livelogs(console, args=None, shell_state=None, **kwargs):
+    """
+    /livelogs [N] - Show the last N lines of the livereload server logs (default: 20)
+    """
+    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.")

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,12 @@ 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")
+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 +23,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 +31,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)

janito/shell/commands/session.py

@@ -0,0 +1,32 @@
+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}")

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:
@@ -40,8 +40,3 @@ def restart_cli():
 def handle_exit(console, **kwargs):
     console.print("[bold red]Exiting chat mode.[/bold red]")
     sys.exit(0)
-
-
-def handle_restart(console, **kwargs):
-    console.print("[bold yellow]Restarting CLI...[/bold yellow]")
-    restart_cli()