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

janito/agent/tools/memory.py

@@ -1,48 +0,0 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-
-
-@register_tool(name="memory")
-class MemoryTool(ToolBase):
-    """
-    Simple in-memory key-value store for demonstration purposes.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.memory = {}
-
-    def run(self, action: str, key: str, value: str = None) -> str:
-        if action == "set":
-            self.report_info(tr("ℹ️ Storing value for key: '{key}' ...", key=key))
-            self.memory[key] = value
-            msg = tr("Value stored for key: '{key}'.", key=key)
-            self.report_success(msg)
-            return msg
-        elif action == "get":
-            self.report_info(tr("ℹ️ Retrieving value for key: '{key}' ...", key=key))
-            if key in self.memory:
-                msg = tr(
-                    "Value for key '{key}': {value}", key=key, value=self.memory[key]
-                )
-                self.report_success(msg)
-                return msg
-            else:
-                msg = tr("Key '{key}' not found.", key=key)
-                self.report_warning(msg)
-                return msg
-        elif action == "delete":
-            if key in self.memory:
-                del self.memory[key]
-                msg = tr("Key '{key}' deleted.", key=key)
-                self.report_success(msg)
-                return msg
-            else:
-                msg = tr("Key '{key}' not found.", key=key)
-                self.report_error(msg)
-                return msg
-        else:
-            msg = tr("Unknown action: {action}", action=action)
-            self.report_error(msg)
-            return msg

janito/agent/tools/outline_file/python_outline.py

@@ -1,71 +0,0 @@
-import re
-from typing import List
-
-
-def parse_python_outline(lines: List[str]):
-    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
-    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
-    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
-    outline = []
-    stack = []  # (type, name, indent, start, parent)
-    for idx, line in enumerate(lines):
-        class_match = class_pat.match(line)
-        func_match = func_pat.match(line)
-        assign_match = assign_pat.match(line)
-        indent = len(line) - len(line.lstrip())
-        if class_match:
-            name = class_match.group(2)
-            parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
-            stack.append(("class", name, indent, idx + 1, parent))
-        elif func_match:
-            name = func_match.group(2)
-            parent = (
-                stack[-1][1]
-                if stack
-                and stack[-1][0] in ("class", "function")
-                and indent > stack[-1][2]
-                else ""
-            )
-            stack.append(("function", name, indent, idx + 1, parent))
-        elif assign_match and indent == 0:
-            var_name = assign_match.group(2)
-            var_type = "const" if var_name.isupper() else "var"
-            outline.append(
-                {
-                    "type": var_type,
-                    "name": var_name,
-                    "start": idx + 1,
-                    "end": idx + 1,
-                    "parent": "",
-                }
-            )
-        while stack and indent < stack[-1][2]:
-            popped = stack.pop()
-            outline.append(
-                {
-                    "type": (
-                        popped[0]
-                        if popped[0] != "function" or popped[3] == 1
-                        else ("method" if popped[4] else "function")
-                    ),
-                    "name": popped[1],
-                    "start": popped[3],
-                    "end": idx,
-                    "parent": popped[4],
-                }
-            )
-    for popped in stack:
-        outline.append(
-            {
-                "type": (
-                    popped[0]
-                    if popped[0] != "function" or popped[3] == 1
-                    else ("method" if popped[4] else "function")
-                ),
-                "name": popped[1],
-                "start": popped[3],
-                "end": len(lines),
-                "parent": popped[4],
-            }
-        )
-    return outline

janito/agent/tools/present_choices_test.py

@@ -1,18 +0,0 @@
-"""
-Test for present_choices tool.
-
-Note: This test is for manual/interactive verification only, as prompt_toolkit dialogs require user interaction.
-"""
-
-from present_choices import present_choices
-
-if __name__ == "__main__":
-    prompt = "Select your favorite fruits:"
-    choices = ["Apple", "Banana", "Cherry", "Date"]
-    print("Single-select test:")
-    selected = present_choices(prompt, choices, multi_select=False)
-    print(f"Selected: {selected}")
-
-    print("\nMulti-select test:")
-    selected_multi = present_choices(prompt, choices, multi_select=True)
-    print(f"Selected: {selected_multi}")

janito/agent/tools/rich_live.py

@@ -1,44 +0,0 @@
-from contextlib import contextmanager
-from rich.live import Live
-from rich.panel import Panel
-from rich.console import Console
-
-console = Console()
-
-_global_live = None
-
-
-@contextmanager
-def global_live_panel(title="Working..."):
-    global _global_live
-    if _global_live is None:
-        _global_live = Live(
-            Panel("", title=title), console=console, refresh_per_second=4
-        )
-        _global_live.start()
-    try:
-        yield _global_live
-    finally:
-        pass  # Do not stop here; stopping is handled explicitly
-
-
-def stop_global_live_panel():
-    global _global_live
-    if _global_live is not None:
-        _global_live.stop()
-        _global_live = None
-
-
-@contextmanager
-def live_panel(title="Working..."):
-    global _global_live
-    if _global_live is not None:
-        # Update the global panel content instead of creating a nested panel
-        _global_live.update(Panel("", title=title))
-        yield _global_live
-    else:
-        # Fallback: create a temporary panel if no global panel is running
-        with Live(
-            Panel("", title=title), console=console, refresh_per_second=4
-        ) as live:
-            yield live

janito/agent/tools/tools_utils.py

@@ -1,56 +0,0 @@
-import os
-import urllib.parse
-from janito.agent.tools.gitignore_utils import filter_ignored
-from janito.agent.runtime_config import runtime_config
-
-
-def display_path(path):
-    """
-    Returns a display-friendly path. If runtime_config['termweb_port'] is set, injects an ANSI hyperlink to the local web file viewer.
-    Args:
-        path (str): Path to display.
-    Returns:
-        str: Display path, optionally as an ANSI hyperlink.
-    """
-    if os.path.isabs(path):
-        disp = path
-    else:
-        disp = os.path.relpath(path)
-    port = runtime_config.get("termweb_port")
-    if port:
-        url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
-        # Use Rich markup for hyperlinks
-        return f"[link={url}]{disp}[/link]"
-    return disp
-
-
-def pluralize(word: str, count: int) -> str:
-    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
-    if count == 1 or word.endswith("s"):
-        return word
-    return word + "s"
-
-
-def find_files_with_extensions(directories, extensions, max_depth=0):
-    """
-    Find files in given directories with specified extensions, respecting .gitignore.
-
-    Args:
-        directories (list[str]): Directories to search.
-        extensions (list[str]): File extensions to include (e.g., ['.py', '.md']).
-        max_depth (int, optional): Maximum directory depth to search. If 0, unlimited.
-    Returns:
-        list[str]: List of matching file paths.
-    """
-    output = []
-    for directory in directories:
-        for root, dirs, files in os.walk(directory):
-            rel_path = os.path.relpath(root, directory)
-            depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-            if max_depth > 0 and depth > max_depth:
-                continue
-            dirs, files = filter_ignored(root, dirs, files)
-            for filename in files:
-                if any(filename.lower().endswith(ext) for ext in extensions):
-                    output.append(os.path.join(root, filename))
-    return output

janito/agent/tools/utils.py

@@ -1,33 +0,0 @@
-import os
-
-
-def expand_path(path: str) -> str:
-    """
-    If ~ is present in the path, expands it to the user's home directory.
-    Otherwise, returns the path unchanged.
-    """
-    if "~" in path:
-        return os.path.expanduser(path)
-    return path
-
-
-def display_path(path: str) -> str:
-    """
-    Returns a user-friendly path for display:
-    - If the path is relative, return it as-is.
-    - If the path starts with ~, keep it as ~.
-    - If the path is under the home directory, replace the home dir with ~.
-    - Else, show the absolute path.
-    """
-    if not (
-        path.startswith("/")
-        or path.startswith("~")
-        or (os.name == "nt" and len(path) > 1 and path[1] == ":")
-    ):
-        return path
-    home = os.path.expanduser("~")
-    if path.startswith("~"):
-        return path
-    if path.startswith(home):
-        return "~" + path[len(home) :]
-    return path

janito/agent/tools/validate_file_syntax.py

@@ -1,163 +0,0 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-import os
-import json
-import yaml
-from janito.agent.tools.utils import display_path
-
-
-@register_tool(name="validate_file_syntax")
-class ValidateFileSyntaxTool(ToolBase):
-    """
-    Validate a file for syntax issues.
-
-    Supported types:
-      - Python (.py, .pyw)
-      - JSON (.json)
-      - YAML (.yml, .yaml)
-      - PowerShell (.ps1)
-      - XML (.xml)
-      - HTML (.html, .htm) [lxml]
-
-    Args:
-        file_path (str): Path to the file to validate.
-    Returns:
-        str: Validation status message. Example:
-            - "✅ Syntax OK"
-            - "⚠️ Warning: Syntax error: <error message>"
-            - "⚠️ Warning: Unsupported file extension: <ext>"
-    """
-
-    def run(self, file_path: str) -> str:
-        disp_path = display_path(file_path)
-        self.report_info(
-            tr("🔎 Validating syntax for: {disp_path} ...", disp_path=disp_path)
-        )
-        ext = os.path.splitext(file_path)[1].lower()
-        try:
-            if ext in [".py", ".pyw"]:
-                import py_compile
-
-                py_compile.compile(file_path, doraise=True)
-            elif ext == ".json":
-                with open(file_path, "r", encoding="utf-8") as f:
-                    json.load(f)
-            elif ext in [".yml", ".yaml"]:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    yaml.safe_load(f)
-            elif ext == ".ps1":
-                from janito.agent.tools.run_powershell_command import (
-                    RunPowerShellCommandTool,
-                )
-
-                ps_tool = RunPowerShellCommandTool()
-                check_cmd = "if (Get-Command Invoke-ScriptAnalyzer -ErrorAction SilentlyContinue) { Write-Output 'PSScriptAnalyzerAvailable' } else { Write-Output 'PSScriptAnalyzerMissing' }"
-                check_result = ps_tool.run(command=check_cmd, timeout=15)
-                if "PSScriptAnalyzerMissing" in check_result:
-                    msg = tr(
-                        "⚠️ Warning: PSScriptAnalyzer is not installed. For best PowerShell syntax validation, install it with:\n    Install-Module -Name PSScriptAnalyzer -Scope CurrentUser\n"
-                    )
-                    self.report_warning(msg)
-                    return msg
-                analyze_cmd = f"Invoke-ScriptAnalyzer -Path '{file_path}' -Severity Error | ConvertTo-Json"
-                analyze_result = ps_tool.run(command=analyze_cmd, timeout=30)
-                if "[]" in analyze_result or analyze_result.strip() == "":
-                    self.report_success(tr("✅ Syntax OK"))
-                    return tr("✅ Syntax valid")
-                else:
-                    msg = tr(
-                        "⚠️ Warning: PowerShell syntax issues found:\n{analyze_result}",
-                        analyze_result=analyze_result,
-                    )
-                    self.report_warning(msg)
-                    return msg
-            elif ext == ".xml":
-                try:
-                    from lxml import etree
-                except ImportError:
-                    msg = tr("⚠️ lxml not installed. Cannot validate XML.")
-                    self.report_warning(msg)
-                    return msg
-                with open(file_path, "rb") as f:
-                    etree.parse(f)
-            elif ext in (".html", ".htm"):
-                try:
-                    from lxml import html
-                except ImportError:
-                    msg = tr("⚠️ lxml not installed. Cannot validate HTML.")
-                    self.report_warning(msg)
-                    return msg
-                with open(file_path, "rb") as f:
-                    html.parse(f)
-                from lxml import etree
-
-                parser = etree.HTMLParser(recover=False)
-                with open(file_path, "rb") as f:
-                    etree.parse(f, parser=parser)
-                if parser.error_log:
-                    errors = "\n".join(str(e) for e in parser.error_log)
-                    raise ValueError(
-                        tr("HTML syntax errors found:\n{errors}", errors=errors)
-                    )
-            elif ext == ".md":
-                import re
-
-                with open(file_path, "r", encoding="utf-8") as f:
-                    content = f.read()
-                errors = []
-                # Rule: Headers must start with # followed by a space
-                for i, line in enumerate(content.splitlines(), 1):
-                    if re.match(r"^#+[^ #]", line):
-                        errors.append(
-                            f"Line {i}: Header missing space after # | {line.strip()}"
-                        )
-                # Rule: Unclosed code blocks
-                if content.count("```") % 2 != 0:
-                    errors.append("Unclosed code block (```) detected")
-                # Rule: Unclosed links/images (flag only if line contains [text]( but not ))
-                for i, line in enumerate(content.splitlines(), 1):
-                    if re.search(r"\[[^\]]*\]\([^)]+$", line):
-                        errors.append(
-                            f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
-                        )
-                # Rule: List items must start with -, *, or + followed by space
-                for i, line in enumerate(content.splitlines(), 1):
-                    # Skip horizontal rules like --- or ***
-                    if re.match(r"^([-*+])\1{1,}", line):
-                        continue
-                    # Skip table rows (lines starting with |)
-                    if line.lstrip().startswith("|"):
-                        continue
-                    # Only flag as list item if there is text after the bullet (not just emphasis)
-                    if re.match(r"^[-*+][^ \n]", line):
-                        stripped = line.strip()
-                        # If the line is surrounded by * and ends with *, it's likely emphasis, not a list
-                        if not (
-                            stripped.startswith("*")
-                            and stripped.endswith("*")
-                            and len(stripped) > 2
-                        ):
-                            errors.append(
-                                f"Line {i}: List item missing space after bullet | {line.strip()}"
-                            )
-                # Rule: Inline code must have even number of backticks
-                if content.count("`") % 2 != 0:
-                    errors.append("Unclosed inline code (`) detected")
-                if errors:
-                    msg = tr(
-                        "⚠️ Warning: Markdown syntax issues found:\n{errors}",
-                        errors="\n".join(errors),
-                    )
-                    self.report_warning(msg)
-                    return msg
-            else:
-                msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
-                self.report_warning(msg)
-                return msg
-            self.report_success(tr("✅ Syntax OK"))
-            return tr("✅ Syntax valid")
-        except Exception as e:
-            msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
-            self.report_warning(msg)
-            return msg

janito/cli_chat_shell/chat_loop.py

@@ -1,163 +0,0 @@
-from janito.agent.rich_message_handler import RichMessageHandler
-from .chat_state import load_chat_state, save_chat_state
-from .chat_ui import setup_prompt_session, print_welcome_message
-from .commands import handle_command
-from janito.agent.conversation_exceptions import EmptyResponseError, ProviderError
-
-# Track the active prompt session for cleanup
-active_prompt_session = None
-
-
-def start_chat_shell(
-    profile_manager,
-    continue_session=False,
-    max_rounds=50,
-    termweb_stdout_path=None,
-    termweb_stderr_path=None,
-):
-    import janito.i18n as i18n
-    from janito.agent.runtime_config import runtime_config
-
-    i18n.set_locale(runtime_config.get("lang", "en"))
-    global active_prompt_session
-    agent = profile_manager.agent
-    message_handler = RichMessageHandler()
-    console = message_handler.console
-
-    # Load state
-    state = load_chat_state(continue_session)
-    if termweb_stdout_path:
-        state["termweb_stdout_path"] = termweb_stdout_path
-    if termweb_stderr_path:
-        state["termweb_stderr_path"] = termweb_stderr_path
-    messages = state["messages"]
-    mem_history = state["mem_history"]
-    last_usage_info_ref = {"value": state["last_usage_info"]}
-    last_elapsed = state["last_elapsed"]
-
-    # Add system prompt if needed (skip in vanilla mode)
-    from janito.agent.runtime_config import runtime_config
-
-    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 messages)
-    ):
-        messages.insert(0, {"role": "system", "content": agent.system_prompt_template})
-
-    print_welcome_message(console, continued=continue_session)
-
-    session = setup_prompt_session(
-        messages, last_usage_info_ref, last_elapsed, mem_history, profile_manager, agent
-    )
-    active_prompt_session = session
-
-    inject_message = state.get("inject_message")
-    if "inject_message" in state:
-        del state["inject_message"]
-
-    while True:
-        try:
-            if inject_message is not None:
-                user_input = inject_message
-                inject_message = None
-                was_paste_mode = False
-            elif state.get("paste_mode"):
-                console.print("")
-                user_input = session.prompt("Multiline> ", multiline=True)
-                was_paste_mode = True
-                state["paste_mode"] = False
-            else:
-                from prompt_toolkit.formatted_text import HTML
-
-                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..."}
-                )
-                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,
-                profile_manager=profile_manager,
-                agent=agent,
-                messages=messages,
-                mem_history=mem_history,
-                state=state,
-            )
-            if result == "exit":
-                break
-            continue
-
-        if not user_input.strip():
-            continue
-
-        mem_history.append_string(user_input)
-        messages.append({"role": "user", "content": user_input})
-
-        import time
-
-        start_time = time.time()
-
-        # No need to propagate verbose; ToolExecutor and others fetch from runtime_config
-
-        try:
-            response = profile_manager.agent.chat(
-                messages,
-                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")
-        last_usage_info_ref["value"] = usage
-
-        # Save conversation and input history
-        save_chat_state(messages, mem_history, last_usage_info_ref["value"])

janito/cli_chat_shell/chat_state.py

@@ -1,38 +0,0 @@
-from .session_manager import (
-    load_last_conversation,
-    load_input_history,
-    save_conversation,
-    save_input_history,
-)
-from prompt_toolkit.history import InMemoryHistory
-
-
-def load_chat_state(continue_session: bool):
-    messages = []
-    last_usage_info = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
-    last_elapsed = None
-    history_list = load_input_history()
-    mem_history = InMemoryHistory()
-    for item in history_list:
-        mem_history.append_string(item)
-    if continue_session:
-        msgs, prompts, usage = load_last_conversation()
-        messages = msgs
-        last_usage_info = usage
-        mem_history = InMemoryHistory()
-        for item in prompts:
-            mem_history.append_string(item)
-    state = {
-        "messages": messages,
-        "mem_history": mem_history,
-        "history_list": history_list,
-        "last_usage_info": last_usage_info,
-        "last_elapsed": last_elapsed,
-    }
-    return state
-
-
-def save_chat_state(messages, mem_history, last_usage_info):
-    prompts = [h for h in mem_history.get_strings()]
-    save_conversation(messages, prompts, last_usage_info)
-    save_input_history(prompts)

janito/cli_chat_shell/commands/history_start.py

@@ -1,37 +0,0 @@
-from prompt_toolkit.history import InMemoryHistory
-import os
-
-
-def handle_start(console, state, **kwargs):
-
-    save_path = os.path.join(".janito", "last_conversation.json")
-
-    # Clear the terminal screen
-    os.system("cls" if os.name == "nt" else "clear")
-
-    # Clear in-memory conversation and prompt history
-    state["messages"].clear()
-    state["history_list"].clear()
-    state["mem_history"] = InMemoryHistory()
-    state["last_usage_info"] = {
-        "prompt_tokens": 0,
-        "completion_tokens": 0,
-        "total_tokens": 0,
-    }
-    state["last_elapsed"] = None
-
-    # Delete saved conversation file if exists
-    if os.path.exists(save_path):
-        try:
-            os.remove(save_path)
-            console.print(
-                "[bold yellow]Deleted saved conversation history.[/bold yellow]"
-            )
-        except Exception as e:
-            console.print(
-                f"[bold red]Failed to delete saved conversation:[/bold red] {e}"
-            )
-
-    console.print(
-        "[bold green]Conversation history has been started (context reset).[/bold green]"
-    )