janito 1.14.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/agent/tools/delete_text_in_file.py

@@ -1,97 +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="delete_text_in_file")
-class DeleteTextInFileTool(ToolBase):
-    """
-    Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
-
-    Args:
-        file_path (str): Path to the file to modify.
-        start_marker (str): The starting delimiter string.
-        end_marker (str): The ending delimiter string.
-        backup (bool, optional): If True, create a backup (.bak) before deleting. Defaults to False.
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    def run(
-        self,
-        file_path: str,
-        start_marker: str,
-        end_marker: str,
-        backup: bool = False,
-    ) -> str:
-        import shutil
-        from janito.agent.tools_utils.utils import display_path
-
-        disp_path = display_path(file_path)
-        backup_path = file_path + ".bak"
-        backup_msg = ""
-        try:
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                content = f.read()
-        except Exception as e:
-            self.report_error(tr(" ❌ Error reading file: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)
-
-        start_count = content.count(start_marker)
-        if start_count > 1:
-            self.report_error("Need more context for start_marker")
-            return (
-                f"Error: start_marker is not unique in {disp_path}. "
-                "Try including the next line(s) for more context."
-            )
-
-        end_count = content.count(end_marker)
-        if end_count > 1:
-            self.report_error("Need more context for end_marker")
-            return (
-                f"Error: end_marker is not unique in {disp_path}. "
-                "Try including the previous line(s) for more context."
-            )
-
-        count = 0
-        new_content = content
-        while True:
-            start_idx = new_content.find(start_marker)
-            if start_idx == -1:
-                break
-            end_idx = new_content.find(end_marker, start_idx + len(start_marker))
-            if end_idx == -1:
-                break
-            # Remove from start_marker to end_marker (inclusive)
-            new_content = (
-                new_content[:start_idx] + new_content[end_idx + len(end_marker) :]
-            )
-            count += 1
-
-        if count == 0:
-            self.report_warning(tr("ℹ️ No blocks found between markers."))
-            return tr(
-                "No blocks found between markers in {file_path}.", file_path=file_path
-            )
-
-        if backup:
-            shutil.copy2(file_path, backup_path)
-            backup_msg = f" (A backup was saved to {backup_path})"
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(new_content)
-
-        self.report_success(
-            tr(
-                "Deleted {count} block(s) between markers in {disp_path}.",
-                count=count,
-                disp_path=disp_path,
-            )
-        )
-        return (
-            tr(
-                "Deleted {count} block(s) between markers in {file_path}.",
-                count=count,
-                file_path=file_path,
-            )
-            + backup_msg
-        )

janito/agent/tools/find_files.py

@@ -1,106 +0,0 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import pluralize, display_path
-from janito.agent.tools_utils.dir_walk_utils import walk_dir_with_gitignore
-from janito.i18n import tr
-import fnmatch
-import os
-
-
-@register_tool(name="find_files")
-class FindFilesTool(ToolBase):
-    """
-    Find files or directories in one or more directories matching a pattern. Respects .gitignore.
-    Args:
-        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory.
-        pattern (str): File pattern(s) to match. Multiple patterns can be separated by spaces. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
-            - If the pattern ends with '/' or '\\', only matching directory names (with trailing slash) are returned, not the files within those directories. For example, pattern '*/' will return only directories at the specified depth.
-        max_depth (int, optional): Maximum directory depth to search. If None, unlimited recursion. If 0, only the top-level directory. If 1, only the root directory (matches 'find . -maxdepth 1').
-        max_results (int, optional): Maximum number of results to return. 0 means no limit (default).
-    Returns:
-        str: Newline-separated list of matching file paths. Example:
-            "/path/to/file1.py\n/path/to/file2.py"
-            "Warning: Empty file pattern provided. Operation skipped."
-            If max_results is reached, appends a note to the output.
-    """
-
-    def _match_directories(self, root, dirs, pat):
-        dir_output = set()
-        dir_pat = pat.rstrip("/\\")
-        for d in dirs:
-            if fnmatch.fnmatch(d, dir_pat):
-                dir_output.add(os.path.join(root, d) + os.sep)
-        return dir_output
-
-    def _match_files(self, root, files, pat):
-        file_output = set()
-        for filename in fnmatch.filter(files, pat):
-            file_output.add(os.path.join(root, filename))
-        return file_output
-
-    def _match_dirs_without_slash(self, root, dirs, pat):
-        dir_output = set()
-        for d in fnmatch.filter(dirs, pat):
-            dir_output.add(os.path.join(root, d))
-        return dir_output
-
-    def run(
-        self, paths: str, pattern: str, max_depth: int = None, max_results: int = 0
-    ) -> str:
-        if not pattern:
-            self.report_warning(tr("ℹ️ Empty file pattern provided."))
-            return tr("Warning: Empty file pattern provided. Operation skipped.")
-        patterns = pattern.split()
-        results = []
-        for directory in paths.split():
-            disp_path = display_path(directory)
-            depth_msg = (
-                tr(" (max depth: {max_depth})", max_depth=max_depth)
-                if max_depth is not None and max_depth > 0
-                else ""
-            )
-            self.report_info(
-                ActionType.READ,
-                tr(
-                    "🔍 Search files '{pattern}' in '{disp_path}'{depth_msg} ...",
-                    pattern=pattern,
-                    disp_path=disp_path,
-                    depth_msg=depth_msg,
-                ),
-            )
-            dir_output = set()
-            count_scanned = 0
-            limit_reached = False
-            for root, dirs, files in walk_dir_with_gitignore(
-                directory, max_depth=max_depth
-            ):
-                for pat in patterns:
-                    if pat.endswith("/") or pat.endswith("\\"):
-                        dir_output.update(self._match_directories(root, dirs, pat))
-                    else:
-                        dir_output.update(self._match_files(root, files, pat))
-                        dir_output.update(
-                            self._match_dirs_without_slash(root, dirs, pat)
-                        )
-                if max_results > 0 and len(dir_output) >= max_results:
-                    limit_reached = True
-                    # Truncate to max_results
-                    dir_output = set(list(dir_output)[:max_results])
-                    break
-            self.report_success(
-                tr(
-                    " ✅ {count} {file_word}{max_flag}",
-                    count=len(dir_output),
-                    file_word=pluralize("file", len(dir_output)),
-                    max_flag=" (max)" if limit_reached else "",
-                )
-            )
-            if directory.strip() == ".":
-                dir_output = {
-                    p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
-                    for p in dir_output
-                }
-            results.extend(sorted(dir_output))
-        result = "\n".join(results)
-        return result

janito/agent/tools/get_file_outline/core.py

@@ -1,81 +0,0 @@
-from janito.agent.tool_registry import register_tool
-from .python_outline import parse_python_outline
-from .markdown_outline import parse_markdown_outline
-from janito.agent.tools_utils.formatting import OutlineFormatter
-import os
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tools_utils.utils import display_path, pluralize
-from janito.i18n import tr
-
-
-@register_tool(name="get_file_outline")
-class GetFileOutlineTool(ToolBase):
-    """
-    Get an outline of a file's structure. Supports Python and Markdown files.
-
-    Args:
-        file_path (str): Path to the file to outline.
-    """
-
-    def run(self, file_path: str) -> str:
-        try:
-            self.report_info(
-                ActionType.READ,
-                tr(
-                    "📄 Outline file '{disp_path}' ...",
-                    disp_path=display_path(file_path),
-                ),
-            )
-            ext = os.path.splitext(file_path)[1].lower()
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                lines = f.readlines()
-            if ext == ".py":
-                outline_items = parse_python_outline(lines)
-                outline_type = "python"
-                table = OutlineFormatter.format_outline_table(outline_items)
-                self.report_success(
-                    tr(
-                        "✅ Outlined {count} {item_word}",
-                        count=len(outline_items),
-                        item_word=pluralize("item", len(outline_items)),
-                    )
-                )
-                return (
-                    tr(
-                        "Outline: {count} items ({outline_type})\n",
-                        count=len(outline_items),
-                        outline_type=outline_type,
-                    )
-                    + table
-                )
-            elif ext == ".md":
-                outline_items = parse_markdown_outline(lines)
-                outline_type = "markdown"
-                table = OutlineFormatter.format_markdown_outline_table(outline_items)
-                self.report_success(
-                    tr(
-                        "✅ Outlined {count} {item_word}",
-                        count=len(outline_items),
-                        item_word=pluralize("item", len(outline_items)),
-                    )
-                )
-                return (
-                    tr(
-                        "Outline: {count} items ({outline_type})\n",
-                        count=len(outline_items),
-                        outline_type=outline_type,
-                    )
-                    + table
-                )
-            else:
-                outline_type = "default"
-                self.report_success(tr("✅ Outlined {count} items", count=len(lines)))
-                return tr(
-                    "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
-                    count=len(lines),
-                    outline_type=outline_type,
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error reading file: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)

janito/agent/tools/present_choices.py

@@ -1,64 +0,0 @@
-from typing import List
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-import questionary
-from questionary import Style
-
-custom_style = Style(
-    [
-        ("pointer", "fg:#ffffff bg:#1976d2 bold"),
-        ("highlighted", "fg:#ffffff bg:#1565c0 bold"),
-        ("answer", "fg:#1976d2 bold"),
-        ("qmark", "fg:#1976d2 bold"),
-    ]
-)
-HAND_EMOJI = "🖐️"  # 🖐️
-
-
-@register_tool(name="present_choices")
-class PresentChoicesTool(ToolBase):
-    """
-    Present a list of options to the user and return the selected option(s).
-
-    Args:
-        prompt (str): The prompt/question to display.
-        choices (List[str]): List of options to present. Use \n in option text for explicit line breaks if needed.
-        multi_select (bool): If True, allow multiple selections.
-    Returns:
-        str: The selected option(s) as a string, or a message if cancelled.
-            - For multi_select=True, returns each selection on a new line, each prefixed with '- '.
-            - For multi_select=False, returns the selected option as a string.
-            - If cancelled, returns 'No selection made.'
-    """
-
-    def run(self, prompt: str, choices: List[str], multi_select: bool = False) -> str:
-        if not choices:
-            return tr("⚠️ No choices provided.")
-        self.report_info(
-            ActionType.EXECUTE,
-            tr(
-                "ℹ️ Prompting user: {prompt} (multi_select={multi_select}) ...",
-                prompt=prompt,
-                multi_select=multi_select,
-            ),
-        )
-        if multi_select:
-            result = questionary.checkbox(
-                prompt, choices=choices, style=custom_style, pointer=HAND_EMOJI
-            ).ask()
-            if result is None:
-                return tr("No selection made.")
-            return (
-                "\n".join(f"- {item}" for item in result)
-                if isinstance(result, list)
-                else f"- {result}"
-            )
-        else:
-            result = questionary.select(
-                prompt, choices=choices, style=custom_style, pointer=HAND_EMOJI
-            ).ask()
-            if result is None:
-                return tr("No selection made.")
-            return str(result)

janito/agent/tools/python_command_runner.py

@@ -1,201 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.i18n import tr
-from janito.agent.runtime_config import runtime_config
-
-
-@register_tool(name="python_command_runner")
-class PythonCommandRunnerTool(ToolBase):
-    """
-    Tool to execute Python code using the `python -c` command-line flag.
-    Args:
-        code (str): The Python code to execute as a string.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    def run(self, code: str, timeout: int = 60) -> str:
-        if not code.strip():
-            self.report_warning(tr("539 Empty code provided."))
-            return tr("Warning: Empty code provided. Operation skipped.")
-        self.report_info(
-            ActionType.EXECUTE, tr("40d Running: python -c ...\n{code}\n", code=code)
-        )
-        try:
-            if runtime_config.get("all_out"):
-                process = subprocess.Popen(
-                    [sys.executable, "-c", code],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    bufsize=1,
-                    universal_newlines=True,
-                    encoding="utf-8",
-                    env={**os.environ, "PYTHONIOENCODING": "utf-8"},
-                )
-                stdout_accum = []
-                stderr_accum = []
-
-                def read_stream(stream, report_func, accum):
-                    for line in stream:
-                        accum.append(line)
-                        report_func(line)
-
-                stdout_thread = threading.Thread(
-                    target=read_stream,
-                    args=(process.stdout, self.report_stdout, stdout_accum),
-                )
-                stderr_thread = threading.Thread(
-                    target=read_stream,
-                    args=(process.stderr, self.report_stderr, stderr_accum),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
-                    )
-                    return tr(
-                        "Code timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_thread.join()
-                stderr_thread.join()
-                self.report_success(
-                    tr("197 Return code {return_code}", return_code=return_code)
-                )
-                stdout = "".join(stdout_accum)
-                stderr = "".join(stderr_accum)
-                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
-                if stderr and stderr.strip():
-                    result += f"\n--- STDERR ---\n{stderr}"
-                return result
-            else:
-                with (
-                    tempfile.NamedTemporaryFile(
-                        mode="w+",
-                        prefix="python_cmd_stdout_",
-                        delete=False,
-                        encoding="utf-8",
-                    ) as stdout_file,
-                    tempfile.NamedTemporaryFile(
-                        mode="w+",
-                        prefix="python_cmd_stderr_",
-                        delete=False,
-                        encoding="utf-8",
-                    ) as stderr_file,
-                ):
-                    process = subprocess.Popen(
-                        [sys.executable, "-c", code],
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True,
-                        bufsize=1,
-                        universal_newlines=True,
-                        encoding="utf-8",
-                        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
-                    )
-                    stdout_lines, stderr_lines = self._stream_process_output(
-                        process, stdout_file, stderr_file
-                    )
-                    return_code = self._wait_for_process(process, timeout)
-                    if return_code is None:
-                        return tr(
-                            "Code timed out after {timeout} seconds.", timeout=timeout
-                        )
-                    stdout_file.flush()
-                    stderr_file.flush()
-                    self.report_success(
-                        tr("197 Return code {return_code}", return_code=return_code)
-                    )
-                    return self._format_result(
-                        stdout_file.name, stderr_file.name, return_code
-                    )
-        except Exception as e:
-            self.report_error(tr("534 Error: {error}", error=e))
-            return tr("Error running code: {error}", error=e)
-
-    def _stream_process_output(self, process, stdout_file, stderr_file):
-        stdout_lines = 0
-        stderr_lines = 0
-
-        def stream_output(stream, file_obj, report_func, count_func):
-            nonlocal stdout_lines, stderr_lines
-            for line in stream:
-                file_obj.write(line)
-                file_obj.flush()
-                report_func(line)
-                if count_func == "stdout":
-                    stdout_lines += 1
-                else:
-                    stderr_lines += 1
-
-        stdout_thread = threading.Thread(
-            target=stream_output,
-            args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
-        )
-        stderr_thread = threading.Thread(
-            target=stream_output,
-            args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
-        )
-        stdout_thread.start()
-        stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
-        return stdout_lines, stderr_lines
-
-    def _wait_for_process(self, process, timeout):
-        try:
-            return process.wait(timeout=timeout)
-        except subprocess.TimeoutExpired:
-            process.kill()
-            self.report_error(
-                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
-            )
-            return None
-
-    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
-        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
-        stdout_lines = stdout_content.count("\n")
-        stderr_lines = stderr_content.count("\n")
-
-        def head_tail(text, n=10):
-            lines = text.splitlines()
-            if len(lines) <= 2 * n:
-                return "\n".join(lines)
-            return "\n".join(
-                lines[:n]
-                + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
-                + lines[-n:]
-            )
-
-        if stdout_lines <= max_lines and stderr_lines <= max_lines:
-            result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- STDERR ---\n{stderr_content}"
-            return result
-        else:
-            result = f"stdout_file: {stdout_file_name} (lines: {stdout_lines})\n"
-            if stderr_lines > 0 and stderr_content.strip():
-                result += f"stderr_file: {stderr_file_name} (lines: {stderr_lines})\n"
-            result += f"returncode: {return_code}\n"
-            result += "--- STDOUT (head/tail) ---\n" + head_tail(stdout_content) + "\n"
-            if stderr_content.strip():
-                result += (
-                    "--- STDERR (head/tail) ---\n" + head_tail(stderr_content) + "\n"
-                )
-            result += "Use the get_lines tool to inspect the contents of these files when needed."
-            return result