janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/shell/commands/tools.py

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

@@ -0,0 +1,28 @@
+def handle_help(console, **kwargs):
+    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):
+    import os
+
+    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/{cli_chat_shell → shell}/commands/verbose.py

@@ -1,11 +1,7 @@
 from janito.agent.runtime_config import runtime_config
 
 
-def handle_verbose(console, state, **kwargs):
-    """
-    /verbose [on|off]
-    Shows or sets verbose mode for the current shell session.
-    """
+def handle_verbose(console, shell_state=None, **kwargs):
     args = kwargs.get("args", [])
     verbose = runtime_config.get("verbose", False)
     if not args:
@@ -27,3 +23,6 @@ def handle_verbose(console, state, **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/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/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

@@ -0,0 +1,257 @@
+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.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
+import os
+from janito.shell.session.manager import get_session_id
+from prompt_toolkit.formatted_text import HTML
+import time
+from janito.shell.input_history import UserInputHistory
+
+
+@dataclass
+class ShellState:
+    mem_history: Any = field(default_factory=InMemoryHistory)
+    conversation_history: Any = field(default_factory=lambda: LLMConversationHistory())
+    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
+    user_input_history: Optional[Any] = None
+
+
+# Track the active prompt session for cleanup
+active_prompt_session = None
+
+
+def load_session(shell_state, continue_session, session_id, profile_manager):
+    from janito.shell.session.manager import load_conversation_by_session_id
+
+    if continue_session and session_id:
+        try:
+            messages, prompts, usage = load_conversation_by_session_id(session_id)
+        except FileNotFoundError as e:
+            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
+        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
+            )
+        shell_state.last_usage_info = usage or {}
+    else:
+        conversation_history = shell_state.conversation_history
+        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
+            )
+    return True
+
+
+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
+                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()
+            try:
+                confirm = (
+                    session.prompt(
+                        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"):
+            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
+        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_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:
+        message_handler.handle_message(
+            {"type": "info", "message": "Request interrupted. Returning to prompt."}
+        )
+        return
+    except ProviderError as e:
+        message_handler.handle_message(
+            {"type": "error", "message": f"Provider error: {e}"}
+        )
+        return
+    except EmptyResponseError as e:
+        message_handler.handle_message({"type": "error", "message": f"Error: {e}"})
+        return
+    except ApiError as e:
+        message_handler.handle_message({"type": "error", "message": str(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
+
+    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
+    )

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/shell/session/manager.py

@@ -0,0 +1,101 @@
+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):
+        return None
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data
+
+
+def load_last_conversation(path=".janito/last_conversation.json"):
+    if not os.path.exists(path):
+        return [], [], None
+    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 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}
+
+    def usage_serializer(obj):
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        return str(obj)
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, default=usage_serializer)
+
+
+def last_conversation_exists(path=".janito/last_conversation.json"):
+    if not os.path.exists(path):
+        return False
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        messages = data.get("messages", [])
+        return bool(messages)
+    except Exception:
+        return False