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

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

@@ -1,4 +1,4 @@
-def handle_sum(console, state, **kwargs):
+def handle_sum(console, shell_state=None, **kwargs):
     """
     Summarize the current chat history and replace it with a summary message.
     """
@@ -7,15 +7,15 @@ def handle_sum(console, state, **kwargs):
         console.print("[bold red]Agent not provided to /sum command.[/bold red]")
         return
 
-    messages = state.get("messages", [])
-    if not messages or len(messages) < 2:
+    history = shell_state.conversation_history.get_messages()
+    if not history or len(history) < 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)
+    system_msg = next((m for m in history if m.get("role") == "system"), None)
 
     # Prepare summary prompt
     summary_prompt = {
@@ -23,7 +23,7 @@ def handle_sum(console, state, **kwargs):
         "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"]
+    convo_for_summary = [m for m in history if m.get("role") != "system"]
     summary_messages = [summary_prompt] + convo_for_summary
 
     try:
@@ -42,7 +42,7 @@ def handle_sum(console, state, **kwargs):
     if system_msg:
         new_history.append(system_msg)
     new_history.append({"role": "assistant", "content": summary_text})
-    state["messages"] = new_history
+    shell_state.conversation_history.set_messages(new_history)
 
     console.print(
         "[bold green]Conversation summarized and history replaced with summary.[/bold green]"

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,20 @@ 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:
+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)

janito/shell/commands/tools.py

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

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

@@ -3,16 +3,16 @@ def handle_help(console, **kwargs):
         """
 [bold green]Available commands:[/bold green]
   /exit, exit     - Exit chat mode
-  /restart  - Restart the CLI
+  /restart  - Start a new conversation
   /help     - Show this help message
   /continue - Restore last saved conversation
-  /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
+  /livelogs  - Show live updates from the server log file (default: server.log)
   /termweb-status - Show status information about the running termweb server
   /verbose [on|off] - Show or set verbose mode for this session
 """
@@ -25,8 +25,9 @@ def handle_clear(console, **kwargs):
     os.system("cls" if os.name == "nt" else "clear")
 
 
-def handle_multi(console, state, **kwargs):
+def handle_multi(console, shell_state=None, **kwargs):
     console.print(
         "[bold yellow]Multiline mode activated. Provide or write your text and press Esc + Enter to submit.[/bold yellow]"
     )
-    state["paste_mode"] = True
+    if shell_state:
+        shell_state.paste_mode = True

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

@@ -1,7 +1,7 @@
 from janito.agent.runtime_config import runtime_config
 
 
-def handle_verbose(console, state, **kwargs):
+def handle_verbose(console, shell_state=None, **kwargs):
     """
     /verbose [on|off]
     Shows or sets verbose mode for the current shell session.

janito/shell/commands.py

@@ -0,0 +1,40 @@
+from janito.agent.tool_registry import get_tool_schemas
+from rich.console import Console
+
+
+def handle_command(cmd, console: Console, shell_state=None):
+    cmd = cmd.strip().lower()
+    if cmd in ("/exit", "exit"):
+        return "exit"
+    if cmd in ("/help", "help"):
+        console.print("[bold cyan]/help[/]: Show this help message")
+        console.print("[bold cyan]/exit[/]: Exit the shell")
+        console.print("[bold cyan]/tools[/]: List available tools")
+        return
+    if cmd in ("/tools", "tools"):
+        table = None
+        try:
+            from rich.table import Table
+
+            table = Table(
+                title="Available Tools", show_lines=True, style="bold magenta"
+            )
+            table.add_column("Name", style="cyan", no_wrap=True)
+            table.add_column("Description", style="green")
+            table.add_column("Parameters", style="yellow")
+            for schema in get_tool_schemas():
+                fn = schema["function"]
+                params = "\n".join(
+                    [
+                        f"[bold]{k}[/]: {v['type']}"
+                        for k, v in fn["parameters"].get("properties", {}).items()
+                    ]
+                )
+                table.add_row(f"[b]{fn['name']}[/b]", fn["description"], params or "-")
+        except Exception as e:
+            console.print(f"[red]Error loading tools: {e}[/red]")
+        if table:
+            console.print(table)
+        return
+    # Unknown command
+    console.print(f"[yellow]Unknown command:[/] {cmd}")

janito/shell/main.py

@@ -0,0 +1,321 @@
+from janito.agent.rich_message_handler import RichMessageHandler
+from prompt_toolkit.history import InMemoryHistory
+from dataclasses import dataclass, field
+from typing import Optional, Any, Dict
+from janito.shell.prompt.session_setup import (
+    setup_prompt_session,
+    print_welcome_message,
+)
+from janito.shell.commands import handle_command
+from janito.agent.conversation_exceptions import EmptyResponseError, ProviderError
+from janito.agent.conversation_history import ConversationHistory
+from janito.agent.tool_use_tracker import ToolUseTracker
+import janito.i18n as i18n
+from janito.agent.runtime_config import runtime_config
+from rich.console import Console
+from collections import Counter
+import os
+from janito.shell.session.manager import get_session_id
+from prompt_toolkit.formatted_text import HTML
+import time
+
+
+def chat_start_summary(conversation_history, console, last_usage_info):
+    def format_tokens(n):
+        if n is None:
+            return "-"
+        if n >= 1_000_000:
+            return f"{n/1_000_000:.2f}m"
+        elif n >= 1_000:
+            return f"{n/1_000:.2f}k"
+        return str(n)
+
+    num_messages = len(conversation_history)
+    roles = [m.get("role") for m in conversation_history.get_messages()]
+    role_counts = {role: roles.count(role) for role in set(roles)}
+    roles_str = ", ".join(
+        f"[bold]{role}[/]: {count}" for role, count in role_counts.items()
+    )
+    stats_lines = [
+        f"[cyan]Messages:[/] [bold]{num_messages}[/]",
+        f"[cyan]Roles:[/] {roles_str}",
+    ]
+    # Use last_usage_info for tokens
+    if last_usage_info:
+        prompt_tokens = last_usage_info.get("prompt_tokens")
+        completion_tokens = last_usage_info.get("completion_tokens")
+        total_tokens = last_usage_info.get("total_tokens")
+        tokens_parts = []
+        if prompt_tokens is not None:
+            tokens_parts.append(f"Prompt: [bold]{format_tokens(prompt_tokens)}[/]")
+        if completion_tokens is not None:
+            tokens_parts.append(
+                f"Completion: [bold]{format_tokens(completion_tokens)}[/]"
+            )
+        if total_tokens is not None:
+            tokens_parts.append(f"Total: [bold]{format_tokens(total_tokens)}[/]")
+        if tokens_parts:
+            stats_lines.append(f"[cyan]Tokens:[/] {', '.join(tokens_parts)}")
+
+    # Add global tool usage stats
+    try:
+        tool_history = ToolUseTracker().get_history()
+        if tool_history:
+            tool_counts = Counter(
+                entry["tool"] for entry in tool_history if "tool" in entry
+            )
+            tools_str = ", ".join(
+                f"[bold]{tool}[/]: {count}" for tool, count in tool_counts.items()
+            )
+            stats_lines.append(f"[cyan]Tools used:[/] {tools_str}")
+    except Exception:
+        pass  # Fail silently if tracker is unavailable
+
+    # Print all stats in a single line, no panel
+    # Print stats in a single line, but tokens info on a separate line if present
+    if len(stats_lines) > 2:
+        console.print(" | ".join(stats_lines[:2]))
+        console.print(stats_lines[2])
+        if len(stats_lines) > 3:
+            console.print(" | ".join(stats_lines[3:]))
+    else:
+        console.print(" | ".join(stats_lines))
+
+
+@dataclass
+class ShellState:
+    mem_history: Any = field(default_factory=InMemoryHistory)
+    conversation_history: Any = field(default_factory=lambda: ConversationHistory())
+    last_usage_info: Dict[str, int] = field(
+        default_factory=lambda: {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        }
+    )
+    last_elapsed: Optional[float] = None
+    termweb_stdout_path: Optional[str] = None
+    termweb_stderr_path: Optional[str] = None
+    livereload_stdout_path: Optional[str] = None
+    livereload_stderr_path: Optional[str] = None
+    paste_mode: bool = False
+    profile_manager: Optional[Any] = None
+
+
+# Track the active prompt session for cleanup
+active_prompt_session = None
+
+
+def start_chat_shell(
+    profile_manager,
+    continue_session=False,
+    session_id=None,
+    max_rounds=100,
+    termweb_stdout_path=None,
+    termweb_stderr_path=None,
+    livereload_stdout_path=None,
+    livereload_stderr_path=None,
+):
+
+    i18n.set_locale(runtime_config.get("lang", "en"))
+    global active_prompt_session
+    agent = profile_manager.agent
+    message_handler = RichMessageHandler()
+    console = message_handler.console
+
+    # Print session id at start
+    from janito.shell.session.manager import load_conversation_by_session_id
+
+    shell_state = ShellState()
+    shell_state.profile_manager = profile_manager
+    if continue_session and session_id:
+        try:
+            messages, prompts, usage = load_conversation_by_session_id(session_id)
+        except FileNotFoundError as e:
+            console.print(f"[bold red]{str(e)}[/bold red]")
+            return
+        # Initialize ConversationHistory with loaded messages
+        shell_state.conversation_history = ConversationHistory(messages)
+        conversation_history = shell_state.conversation_history
+        # Always refresh the system prompt in the loaded history
+        found = False
+        for msg in conversation_history.get_messages():
+            if msg.get("role") == "system":
+                msg["content"] = profile_manager.system_prompt_template
+                found = True
+                break
+        if not found:
+            conversation_history.set_system_message(
+                profile_manager.system_prompt_template
+            )
+        # Optionally set prompts/usage if needed
+        shell_state.last_usage_info = usage or {}
+    else:
+        conversation_history = shell_state.conversation_history
+        # Add system prompt if needed (skip in vanilla mode)
+
+        if (
+            profile_manager.system_prompt_template
+            and (
+                not runtime_config.get("vanilla_mode", False)
+                or runtime_config.get("system_prompt_template")
+            )
+            and not any(
+                m.get("role") == "system" for m in conversation_history.get_messages()
+            )
+        ):
+            conversation_history.set_system_message(
+                profile_manager.system_prompt_template
+            )
+    mem_history = shell_state.mem_history
+
+    def last_usage_info_ref():
+        return shell_state.last_usage_info
+
+    last_elapsed = shell_state.last_elapsed
+
+    print_welcome_message(console, continue_id=session_id if continue_session else None)
+
+    session = setup_prompt_session(
+        lambda: conversation_history.get_messages(),
+        last_usage_info_ref,
+        last_elapsed,
+        mem_history,
+        profile_manager,
+        agent,
+        lambda: conversation_history,
+    )
+    active_prompt_session = session
+
+    while True:
+        try:
+
+            if shell_state.paste_mode:
+                user_input = session.prompt("Multiline> ", multiline=True)
+                was_paste_mode = True
+                shell_state.paste_mode = False
+            else:
+                user_input = session.prompt(
+                    HTML("<inputline>💬 </inputline>"), multiline=False
+                )
+                was_paste_mode = False
+        except EOFError:
+            console.print("\n[bold red]Exiting...[/bold red]")
+            break
+        except KeyboardInterrupt:
+            console.print()  # Move to next line
+            try:
+                confirm = (
+                    session.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()
+                )
+            except KeyboardInterrupt:
+                message_handler.handle_message(
+                    {"type": "error", "message": "Exiting..."}
+                )
+                break
+            if confirm == "y":
+                message_handler.handle_message(
+                    {"type": "error", "message": "Exiting..."}
+                )
+                conversation_history.add_message(
+                    {"role": "system", "content": "[Session ended by user]"}
+                )
+                break
+            else:
+                continue
+
+        cmd_input = user_input.strip().lower()
+        if not was_paste_mode and (cmd_input.startswith("/") or cmd_input == "exit"):
+            # Treat both '/exit' and 'exit' as commands
+            result = handle_command(
+                user_input.strip(),
+                console,
+                shell_state=shell_state,
+            )
+            if result == "exit":
+                conversation_history.add_message(
+                    {"role": "system", "content": "[Session ended by user]"}
+                )
+                break
+            continue
+
+        if not user_input.strip():
+            continue
+
+        mem_history.append_string(user_input)
+        conversation_history.add_message({"role": "user", "content": user_input})
+
+        start_time = time.time()
+
+        # No need to propagate verbose; ToolExecutor and others fetch from runtime_config
+
+        # Clear the screen before starting LLM conversation
+        console = Console()
+        console.clear()
+
+        # Print a summary of the current conversation history
+
+        chat_start_summary(conversation_history, console, shell_state.last_usage_info)
+
+        try:
+            response = profile_manager.agent.chat(
+                conversation_history,
+                max_rounds=max_rounds,
+                message_handler=message_handler,
+                spinner=True,
+            )
+        except KeyboardInterrupt:
+            message_handler.handle_message(
+                {"type": "info", "message": "Request interrupted. Returning to prompt."}
+            )
+            continue
+        except ProviderError as e:
+            message_handler.handle_message(
+                {"type": "error", "message": f"Provider error: {e}"}
+            )
+            continue
+        except EmptyResponseError as e:
+            message_handler.handle_message({"type": "error", "message": f"Error: {e}"})
+            continue
+        last_elapsed = time.time() - start_time
+
+        usage = response.get("usage")
+        if usage:
+            for k in ("prompt_tokens", "completion_tokens", "total_tokens"):
+                shell_state.last_usage_info[k] = usage.get(k, 0)
+
+        # --- Ensure assistant and tool messages are added to ConversationHistory ---
+        # If the last message is not an assistant/tool, add the response content
+        content = response.get("content")
+        if content and (
+            len(conversation_history) == 0
+            or conversation_history.get_messages()[-1].get("role") != "assistant"
+        ):
+            conversation_history.add_message({"role": "assistant", "content": content})
+        # Optionally, add tool messages if present in response (extend here if needed)
+        # ---------------------------------------------------------------------------
+
+        # --- Save conversation history after each assistant reply ---
+        session_id_to_save = session_id if session_id else get_session_id()
+        history_dir = os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
+        os.makedirs(history_dir, exist_ok=True)
+        history_path = os.path.join(history_dir, f"{session_id_to_save}.json")
+        conversation_history.to_json_file(history_path)
+        # -----------------------------------------------------------
+
+    # After exiting the main loop, print restart info if conversation has >1 message
+
+    # --- Save conversation history to .janito/chat_history/(session_id).json ---
+    session_id_to_save = session_id if session_id else get_session_id()
+    history_dir = os.path.join(os.path.expanduser("~"), ".janito", "chat_history")
+    os.makedirs(history_dir, exist_ok=True)
+    history_path = os.path.join(history_dir, f"{session_id_to_save}.json")
+    conversation_history.to_json_file(history_path)
+    # -------------------------------------------------------------------------

janito/{cli_chat_shell/shell_command_completer.py → shell/prompt/completer.py}

@@ -4,7 +4,7 @@ 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
+        from janito.shell.commands import COMMAND_HANDLERS
 
         # Only commands starting with '/'
         self.commands = sorted(

janito/{cli_chat_shell/chat_ui.py → shell/prompt/session_setup.py}

@@ -1,19 +1,31 @@
-from .ui import print_welcome, get_toolbar_func, get_prompt_session
+from janito.shell.ui.interactive import (
+    print_welcome,
+    get_toolbar_func,
+    get_prompt_session,
+)
 from janito import __version__
 from janito.agent.config import effective_config
 from janito.agent.runtime_config import runtime_config
+from janito.shell.session.manager import get_session_id
 
 
 def setup_prompt_session(
-    messages, last_usage_info_ref, last_elapsed, mem_history, profile_manager, agent
+    messages,
+    last_usage_info_ref,
+    last_elapsed,
+    mem_history,
+    profile_manager,
+    agent,
+    history_ref,
 ):
     model_name = getattr(agent, "model", None)
+    session_id = get_session_id()
 
     def get_messages():
         return messages
 
     def get_usage():
-        return last_usage_info_ref["value"]
+        return last_usage_info_ref()
 
     def get_elapsed():
         return last_elapsed
@@ -32,11 +44,13 @@ def setup_prompt_session(
                 )
                 else (runtime_config.get("role") or effective_config.get("role"))
             ),
+            session_id=session_id,
+            history_ref=history_ref,
         ),
         mem_history,
     )
     return session
 
 
-def print_welcome_message(console, continued):
-    print_welcome(console, version=__version__, continued=continued)
+def print_welcome_message(console, continue_id=None):
+    print_welcome(console, version=__version__, continue_id=continue_id)

janito/{cli_chat_shell/session_manager.py → shell/session/manager.py}

@@ -2,6 +2,35 @@ import os
 import json
 from datetime import datetime
 
+# --- Session ID generation ---
+_current_session_id = None
+
+
+def generate_session_id():
+    # Use seconds since start of year, encode as base36 for shortness
+    now = datetime.now()
+    start_of_year = datetime(now.year, 1, 1)
+    seconds = int((now - start_of_year).total_seconds())
+    chars = "0123456789abcdefghijklmnopqrstuvwxyz"
+    out = ""
+    n = seconds
+    while n:
+        n, r = divmod(n, 36)
+        out = chars[r] + out
+    return out or "0"
+
+
+def reset_session_id():
+    global _current_session_id
+    _current_session_id = None
+
+
+def get_session_id():
+    global _current_session_id
+    if _current_session_id is None:
+        _current_session_id = generate_session_id()
+    return _current_session_id
+
 
 def load_last_summary(path=".janito/last_conversation.json"):
     if not os.path.exists(path):
@@ -22,9 +51,30 @@ def load_last_conversation(path=".janito/last_conversation.json"):
     return messages, prompts, usage
 
 
-def save_conversation(
-    messages, prompts, usage_info=None, path=".janito/last_conversation.json"
-):
+def load_conversation_by_session_id(session_id):
+    path = os.path.join(".janito", "chat_history", f"{session_id}.json")
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Session file not found: {path}")
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    messages = data.get("messages", [])
+    prompts = data.get("prompts", [])
+    usage = data.get("last_usage_info")
+    return messages, prompts, usage
+
+
+def save_conversation(messages, prompts, usage_info=None, path=None):
+    # Do not save if only one message and it is a system message (noop session)
+    if (
+        isinstance(messages, list)
+        and len(messages) == 1
+        and messages[0].get("role") == "system"
+    ):
+        return
+
+    if path is None:
+        session_id = get_session_id()
+        path = os.path.join(".janito", "chat_history", f"{session_id}.json")
     os.makedirs(os.path.dirname(path), exist_ok=True)
     data = {"messages": messages, "prompts": prompts, "last_usage_info": usage_info}