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

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/run_python_command.py

@@ -1,163 +0,0 @@
-import subprocess
-import tempfile
-import sys
-import os
-from janito.agent.tool_base import ToolBase
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-
-
-@register_tool(name="run_python_command")
-class RunPythonCommandTool(ToolBase):
-    """
-    Tool to execute Python code in a subprocess and capture output.
-    Args:
-        code (str): The Python code to execute.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
-    Returns:
-        str: File paths and line counts for stdout and stderr, or direct output if small enough.
-    """
-
-    def run(
-        self,
-        code: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        interactive: bool = False,
-    ) -> str:
-        if not code.strip():
-            self.report_warning(
-                tr("⚠️ Warning: Empty code provided. Operation skipped.")
-            )
-            return tr("Warning: Empty code provided. Operation skipped.")
-        self.report_info(tr("🐍 Running Python code: ...\n{code}\n", code=code))
-        if interactive:
-            self.report_info(
-                tr(
-                    "⚠️  Warning: This code might be interactive, require user input, and might hang."
-                )
-            )
-        sys.stdout.flush()
-        if require_confirmation:
-            confirmed = self.confirm_action(
-                tr("Do you want to execute this Python code?")
-            )
-            if not confirmed:
-                self.report_warning(tr("Execution cancelled by user."))
-                return tr("Execution cancelled by user.")
-        try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    suffix=".py",
-                    prefix="run_python_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as code_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="run_python_stdout_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+",
-                    prefix="run_python_stderr_",
-                    delete=False,
-                    encoding="utf-8",
-                ) as stderr_file,
-            ):
-                code_file.write(code)
-                code_file.flush()
-                env = os.environ.copy()
-                env["PYTHONIOENCODING"] = "utf-8"
-                process = subprocess.Popen(
-                    [sys.executable, code_file.name],
-                    stdout=stdout_file,
-                    stderr=stderr_file,
-                    text=True,
-                    env=env,
-                )
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(" ❌ Timed out after {timeout} seconds.", timeout=timeout)
-                    )
-                    return tr(
-                        "Code timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_file.flush()
-                stderr_file.flush()
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        self.report_stdout(line)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        self.report_stderr(line)
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
-                self.report_success(
-                    tr(" ✅ return code {return_code}", return_code=return_code)
-                )
-                warning_msg = ""
-                if interactive:
-                    warning_msg = tr(
-                        "⚠️  Warning: This code might be interactive, require user input, and might hang.\n"
-                    )
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_content = out_f.read()
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_content = err_f.read()
-                max_lines = 100
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = warning_msg + tr(
-                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
-                        return_code=return_code,
-                        stdout_content=stdout_content,
-                    )
-                    if stderr_content.strip():
-                        result += tr(
-                            "\n--- STDERR ---\n{stderr_content}",
-                            stderr_content=stderr_content,
-                        )
-                    return result
-                else:
-                    result = warning_msg + tr(
-                        "stdout_file: {stdout_file} (lines: {stdout_lines})\n",
-                        stdout_file=stdout_file.name,
-                        stdout_lines=stdout_lines,
-                    )
-                    if stderr_lines > 0 and stderr_content.strip():
-                        result += tr(
-                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
-                            stderr_file=stderr_file.name,
-                            stderr_lines=stderr_lines,
-                        )
-                    result += tr(
-                        "returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed.",
-                        return_code=return_code,
-                    )
-                    return result
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error running code: {error}", error=e)

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/runner/cli_main.py

@@ -1,180 +0,0 @@
-import sys
-import socket
-from janito.agent.profile_manager import AgentProfileManager
-from janito.agent.runtime_config import unified_config, runtime_config
-from janito.agent.config import get_api_key
-from janito import __version__
-from janito.agent.conversation_exceptions import (
-    MaxRoundsExceededError,
-    EmptyResponseError,
-    ProviderError,
-)
-
-
-def is_port_free(port):
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        return s.connect_ex(("localhost", port)) != 0
-
-
-def run_cli(args):
-    if args.version:
-        print(f"janito version {__version__}")
-        sys.exit(0)
-
-    # Set vanilla mode if -V/--vanilla is passed
-    if getattr(args, "vanilla", False):
-        runtime_config.set("vanilla_mode", True)
-
-    # Normalize all verbose flags into runtime_config
-    for flag in [
-        "verbose_http",
-        "verbose_http_raw",
-        "verbose_response",
-        "verbose_reason",
-        "verbose_tools",
-        "verbose_events",
-        "verbose_stream",
-    ]:
-        if hasattr(args, flag):
-            runtime_config.set(flag, getattr(args, flag, False))
-
-    role = args.role or unified_config.get("role", "software engineer")
-    if args.role:
-        runtime_config.set("role", args.role)
-    if getattr(args, "model", None):
-        runtime_config.set("model", args.model)
-    if getattr(args, "max_tools", None) is not None:
-        runtime_config.set("max_tools", args.max_tools)
-    if getattr(args, "trust_tools", False):
-        runtime_config.set("trust_tools", True)
-    if not getattr(args, "prompt", None):
-        interaction_mode = "chat"
-    else:
-        interaction_mode = "prompt"
-    profile = "base"
-    # PATCH: Pass lang from args or runtime_config to AgentProfileManager
-    lang = getattr(args, "lang", None) or runtime_config.get("lang", "en")
-    profile_manager = AgentProfileManager(
-        api_key=get_api_key(),
-        model=unified_config.get("model"),
-        role=role,
-        profile_name=profile,
-        interaction_mode=interaction_mode,
-        verbose_tools=args.verbose_tools,
-        base_url=unified_config.get("base_url", "https://openrouter.ai/api/v1"),
-        azure_openai_api_version=unified_config.get(
-            "azure_openai_api_version", "2023-05-15"
-        ),
-        use_azure_openai=unified_config.get("use_azure_openai", False),
-        lang=lang,
-    )
-    profile_manager.refresh_prompt()
-    if getattr(args, "show_system", False):
-        print(profile_manager.render_prompt())
-        sys.exit(0)
-    if args.max_tokens is not None:
-        runtime_config.set("max_tokens", args.max_tokens)
-    if getattr(args, "verbose_reason", False):
-        runtime_config.set("verbose_reason", True)
-
-    # --- termweb integration ---
-    termweb_proc = None
-    selected_port = None
-    if (
-        not getattr(args, "no_termweb", False)
-        and interaction_mode == "chat"
-        and not runtime_config.get("vanilla_mode", False)
-    ):
-        default_port = 8088
-        max_port = 8100
-        requested_port = args.termweb_port
-        if requested_port == default_port:
-            for port in range(default_port, max_port + 1):
-                if is_port_free(port):
-                    selected_port = port
-                    break
-            if selected_port is None:
-                print(
-                    f"[red]No free port found for termweb in range {default_port}-{max_port}.[/red]"
-                )
-                sys.exit(1)
-        else:
-            if not is_port_free(requested_port):
-                print(f"[red]Port {requested_port} is not available for termweb.[/red]")
-                sys.exit(1)
-            selected_port = requested_port
-        runtime_config.set("termweb_port", selected_port)
-        from janito.cli.termweb_starter import start_termweb
-
-        termweb_proc, started, termweb_stdout_path, termweb_stderr_path = start_termweb(
-            selected_port
-        )
-        # Store last running port in .janito/config.json if started
-        if started:
-            from janito.agent.config import local_config
-
-            local_config.set("termweb_last_running_port", selected_port)
-            local_config.save()
-
-    # --- End termweb integration ---
-    try:
-        if not getattr(args, "prompt", None):
-            from janito.cli_chat_shell.chat_loop import start_chat_shell
-
-            start_chat_shell(
-                profile_manager,
-                continue_session=getattr(args, "continue_session", False),
-                termweb_stdout_path=(
-                    termweb_stdout_path if "termweb_stdout_path" in locals() else None
-                ),
-                termweb_stderr_path=(
-                    termweb_stderr_path if "termweb_stderr_path" in locals() else None
-                ),
-            )
-            sys.exit(0)
-        # --- Prompt mode ---
-        prompt = args.prompt
-        from rich.console import Console
-        from janito.agent.rich_message_handler import RichMessageHandler
-
-        console = Console()
-        message_handler = RichMessageHandler()
-        messages = []
-        system_prompt_override = runtime_config.get("system_prompt_template")
-        if system_prompt_override:
-            # Só adiciona system prompt se NÃO for vanilla, ou se foi explicitamente passado via --system
-            if not runtime_config.get("vanilla_mode", False) or getattr(
-                args, "system", None
-            ):
-                messages.append({"role": "system", "content": system_prompt_override})
-        elif profile_manager.system_prompt_template and not runtime_config.get(
-            "vanilla_mode", False
-        ):
-            messages.append(
-                {"role": "system", "content": profile_manager.system_prompt_template}
-            )
-        messages.append({"role": "user", "content": prompt})
-        try:
-            max_rounds = 50
-            profile_manager.agent.chat(
-                messages,
-                message_handler=message_handler,
-                spinner=True,
-                max_rounds=max_rounds,
-                stream=getattr(args, "stream", False),
-            )
-        except MaxRoundsExceededError:
-            console.print("[red]Max conversation rounds exceeded.[/red]")
-        except ProviderError as e:
-            console.print(f"[red]Provider error:[/red] {e}")
-        except EmptyResponseError as e:
-            console.print(f"[red]Error:[/red] {e}")
-    except KeyboardInterrupt:
-        from rich.console import Console
-
-        console = Console()
-        console.print("[yellow]Interrupted by user.[/yellow]")
-    finally:
-        if termweb_proc:
-            termweb_proc.terminate()
-            termweb_proc.wait()