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

janito/shell/commands/tools.py

@@ -21,3 +21,6 @@ def handle_tools(console, args=None, shell_state=None):
         console.print(f"[red]Error loading tools: {e}[/red]")
         return
     console.print(table)
+
+
+handle_tools.help_text = "List available tools"

janito/shell/commands/track.py

@@ -0,0 +1,36 @@
+from janito.agent.tool_use_tracker import ToolUseTracker
+from rich.console import Console
+from rich.table import Table
+
+
+def handle_track(console: Console, args=None, shell_state=None):
+    tracker = ToolUseTracker.instance()
+    history = tracker.get_history()
+    if not history:
+        console.print("[bold yellow]No tool usage history found.[/bold yellow]")
+        return
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Tool")
+    table.add_column("Params/Result")
+    for idx, entry in enumerate(history, 1):
+        tool = entry["tool"]
+        params = entry["params"].copy()
+        result = entry.get("result", "")
+        # For create/replace file, trim content in params only
+        if tool in ("create_file", "replace_file") and "content" in params:
+            content = params["content"]
+            if isinstance(content, str):
+                lines = content.splitlines()
+                if len(lines) > 3:
+                    params["content"] = (
+                        "\n".join(lines[:2])
+                        + f"\n... (trimmed, {len(lines)} lines total)"
+                    )
+                elif len(content) > 120:
+                    params["content"] = content[:120] + "... (trimmed)"
+                else:
+                    params["content"] = content
+        param_result = f"{params}\n--- Result ---\n{result}" if result else str(params)
+        table.add_row(str(idx), tool, param_result)
+    console.print(table)

janito/shell/commands/utility.py

@@ -1,22 +1,11 @@
 def handle_help(console, **kwargs):
-    console.print(
-        """
-[bold green]Available commands:[/bold green]
-  /exit, exit     - Exit chat mode
-  /restart  - Start a new conversation
-  /help     - Show this help message
-  /continue - Restore last saved conversation
-  /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
-"""
-    )
+    from janito.shell.commands import COMMAND_HANDLERS
+
+    console.print("[bold green]Available commands:[/bold green]")
+    for cmd, handler in COMMAND_HANDLERS.items():
+        help_text = getattr(handler, "help_text", None)
+        if help_text:
+            console.print(f"  {cmd} - {help_text}")
 
 
 def handle_clear(console, **kwargs):
@@ -25,9 +14,15 @@ def handle_clear(console, **kwargs):
     os.system("cls" if os.name == "nt" else "clear")
 
 
+handle_clear.help_text = "Clear the terminal screen"
+
+
 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]"
     )
     if shell_state:
         shell_state.paste_mode = True
+
+
+handle_multi.help_text = "Provide multiline input as next message"

janito/shell/commands/verbose.py

@@ -2,10 +2,6 @@ from janito.agent.runtime_config import runtime_config
 
 
 def handle_verbose(console, shell_state=None, **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:
@@ -27,3 +23,6 @@ def handle_verbose(console, shell_state=None, **kwargs):
         )
     else:
         console.print("[bold red]Usage:[/bold red] /verbose [on|off]")
+
+
+handle_verbose.help_text = "Show or set verbose mode for this session"

janito/shell/input_history.py

@@ -0,0 +1,62 @@
+import os
+import json
+from datetime import datetime
+from typing import List, Any, Dict
+
+
+class UserInputHistory:
+    """
+    Handles loading, saving, and appending of user input history for the shell.
+    Each day's history is stored in a line-delimited JSON file (.json.log) under .janito/input_history/.
+    Each line is a JSON dict, e.g., {"input": ..., "ts": ...}
+    """
+
+    def __init__(self, history_dir=None):
+        self.history_dir = history_dir or os.path.join(".janito", "input_history")
+        os.makedirs(self.history_dir, exist_ok=True)
+
+    def _get_today_file(self):
+        today_str = datetime.now().strftime("%y%m%d")
+        return os.path.join(self.history_dir, f"{today_str}.json.log")
+
+    def load(self) -> List[Dict[str, Any]]:
+        """Load today's input history as a list of dicts."""
+        history_file = self._get_today_file()
+        history = []
+        try:
+            with open(history_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        history.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        continue
+        except FileNotFoundError:
+            pass
+        return history
+
+    def sanitize_surrogates(self, s):
+        if isinstance(s, str):
+            return s.encode("utf-8", errors="replace").decode("utf-8")
+        return s
+
+    def append(self, input_str: str):
+        """Append a new input as a JSON dict to today's history file."""
+        history_file = self._get_today_file()
+        input_str = self.sanitize_surrogates(input_str)
+        entry = {"input": input_str, "ts": datetime.now().isoformat()}
+        with open(history_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    def save(self, history_list: List[Any]):
+        """Overwrite today's history file with the given list (for compatibility)."""
+        history_file = self._get_today_file()
+        with open(history_file, "w", encoding="utf-8") as f:
+            for item in history_list:
+                if isinstance(item, dict):
+                    f.write(json.dumps(item, ensure_ascii=False) + "\n")
+                else:
+                    entry = {"input": str(item), "ts": datetime.now().isoformat()}
+                    f.write(json.dumps(entry, ensure_ascii=False) + "\n")

janito/shell/main.py

@@ -8,84 +8,22 @@ from janito.shell.prompt.session_setup import (
 )
 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
+from janito.agent.api_exceptions import ApiError
+from janito.agent.llm_conversation_history import LLMConversationHistory
 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))
+from janito.shell.input_history import UserInputHistory
 
 
 @dataclass
 class ShellState:
     mem_history: Any = field(default_factory=InMemoryHistory)
-    conversation_history: Any = field(default_factory=lambda: ConversationHistory())
+    conversation_history: Any = field(default_factory=lambda: LLMConversationHistory())
     last_usage_info: Dict[str, int] = field(
         default_factory=lambda: {
             "prompt_tokens": 0,
@@ -100,44 +38,26 @@ class ShellState:
     livereload_stderr_path: Optional[str] = None
     paste_mode: bool = False
     profile_manager: Optional[Any] = None
+    user_input_history: 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
+def load_session(shell_state, continue_session, session_id, profile_manager):
     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)
+            shell_state.profile_manager.agent.message_handler.console.print(
+                f"[bold red]{str(e)}[/bold red]"
+            )
+            return False
+        shell_state.conversation_history = LLMConversationHistory(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":
@@ -148,12 +68,9 @@ def start_chat_shell(
             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 (
@@ -167,29 +84,18 @@ def start_chat_shell(
             conversation_history.set_system_message(
                 profile_manager.system_prompt_template
             )
-    mem_history = shell_state.mem_history
+    return True
 
-    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
 
+def handle_prompt_loop(
+    shell_state, session, profile_manager, agent, max_rounds, session_id
+):
+    global active_prompt_session
+    conversation_history = shell_state.conversation_history
+    message_handler = RichMessageHandler()
+    console = message_handler.console
     while True:
         try:
-
             if shell_state.paste_mode:
                 user_input = session.prompt("Multiline> ", multiline=True)
                 was_paste_mode = True
@@ -203,11 +109,10 @@ def start_chat_shell(
             console.print("\n[bold red]Exiting...[/bold red]")
             break
         except KeyboardInterrupt:
-            console.print()  # Move to next line
+            console.print()
             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>"
                         )
@@ -230,10 +135,8 @@ def start_chat_shell(
                 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,
@@ -245,77 +148,153 @@ def start_chat_shell(
                 )
                 break
             continue
-
         if not user_input.strip():
             continue
-
-        mem_history.append_string(user_input)
+        shell_state.mem_history.append_string(user_input)
+        shell_state.user_input_history.append(user_input)
         conversation_history.add_message({"role": "user", "content": user_input})
+        handle_chat(shell_state, profile_manager, agent, max_rounds, session_id)
+    # Save conversation history after exiting
+    save_conversation_history(conversation_history, session_id)
+
+
+def handle_keyboard_interrupt(conversation_history, message_handler):
+    removed_count = 0
+    while (
+        conversation_history.last_message()
+        and conversation_history.last_message().get("role") != "assistant"
+    ):
+        conversation_history.remove_last_message()
+        removed_count += 1
+    # Remove the assistant message itself, if present
+    if (
+        conversation_history.last_message()
+        and conversation_history.last_message().get("role") == "assistant"
+    ):
+        conversation_history.remove_last_message()
+        removed_count += 1
+    message_handler.handle_message(
+        {
+            "type": "info",
+            "message": f"\nLast turn cleared due to interruption. Returning to prompt. (removed {removed_count} last msgs)\n",
+        }
+    )
 
-        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
+def handle_chat_error(message_handler, error_type, error):
+    if error_type == "ProviderError":
+        message_handler.handle_message(
+            {"type": "error", "message": f"Provider error: {error}"}
+        )
+    elif error_type == "EmptyResponseError":
+        message_handler.handle_message({"type": "error", "message": f"Error: {error}"})
+    elif error_type == "ApiError":
+        message_handler.handle_message({"type": "error", "message": str(error)})
+    elif error_type == "Exception":
+        import traceback
+
+        tb = traceback.format_exc()
+        message_handler.handle_message(
+            {
+                "type": "error",
+                "message": f"Unexpected error: {error}\n{tb}\nReturning to prompt.",
+            }
+        )
+
+
+def handle_chat(shell_state, profile_manager, agent, max_rounds, session_id):
+    conversation_history = shell_state.conversation_history
+    message_handler = RichMessageHandler()
+    console = message_handler.console
+    start_time = time.time()
+    try:
+        response = profile_manager.agent.chat(
+            conversation_history,
+            max_rounds=max_rounds,
+            message_handler=message_handler,
+            spinner=True,
+        )
+    except KeyboardInterrupt:
+        handle_keyboard_interrupt(conversation_history, message_handler)
+        return
+    except ProviderError as e:
+        handle_chat_error(message_handler, "ProviderError", e)
+        return
+    except EmptyResponseError as e:
+        handle_chat_error(message_handler, "EmptyResponseError", e)
+        return
+    except ApiError as e:
+        handle_chat_error(message_handler, "ApiError", e)
+        return
+    except Exception as e:
+        handle_chat_error(message_handler, "Exception", e)
+        return
+    shell_state.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)
+    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})
+
+
+def save_conversation_history(conversation_history, session_id):
+    from janito.shell.session.manager import get_session_id
 
-    # --- 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)
+    session_id_to_save = session_id if session_id else get_session_id()
     history_path = os.path.join(history_dir, f"{session_id_to_save}.json")
     conversation_history.to_json_file(history_path)
-    # -------------------------------------------------------------------------
+
+
+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
+    console.clear()
+    shell_state = ShellState()
+    shell_state.profile_manager = profile_manager
+    user_input_history = UserInputHistory()
+    user_input_dicts = user_input_history.load()
+    mem_history = shell_state.mem_history
+    for item in user_input_dicts:
+        if isinstance(item, dict) and "input" in item:
+            mem_history.append_string(item["input"])
+    shell_state.user_input_history = user_input_history
+    if not load_session(shell_state, continue_session, session_id, profile_manager):
+        return
+
+    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: shell_state.conversation_history.get_messages(),
+        last_usage_info_ref,
+        last_elapsed,
+        mem_history,
+        profile_manager,
+        agent,
+        lambda: shell_state.conversation_history,
+    )
+    active_prompt_session = session
+    handle_prompt_loop(
+        shell_state, session, profile_manager, agent, max_rounds, session_id
+    )