janito 3.6.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

janito/plugins/tools/core/get_file_outline/core.py

@@ -1,122 +0,0 @@
-from janito.tools.adapters.local.adapter import register_local_tool
-from .python_outline import parse_python_outline
-from .markdown_outline import parse_markdown_outline
-from janito.formatting import OutlineFormatter
-from .java_outline import parse_java_outline
-import os
-from janito.tools.path_utils import expand_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.tool_utils import display_path, pluralize
-from janito.i18n import tr
-
-from ..decorators import register_core_tool
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class GetFileOutline(ToolBase):
-    """
-    Get an outline of a file's structure. Supports Python and Markdown files.
-
-    Args:
-        path (str): Path to the file to outline.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "get_file_outline"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        try:
-            path = expand_path(path)
-            self.report_action(
-                tr(
-                    "📄 Outline file '{disp_path}' ...",
-                    disp_path=display_path(path),
-                ),
-                ReportAction.READ,
-            )
-            ext = os.path.splitext(path)[1].lower()
-            with open(path, "r", encoding="utf-8", errors="replace") as f:
-                lines = f.readlines()
-            return self._outline_by_extension(ext, lines)
-        except Exception as e:
-            self.report_error(
-                tr("❌ Error reading file: {error}", error=e),
-                ReportAction.READ,
-            )
-            return tr("Error reading file: {error}", error=e)
-
-    def _outline_by_extension(self, ext, lines):
-        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)),
-                ),
-                ReportAction.READ,
-            )
-            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)),
-                ),
-                ReportAction.READ,
-            )
-            return (
-                tr(
-                    "Outline: {count} items ({outline_type})\n",
-                    count=len(outline_items),
-                    outline_type=outline_type,
-                )
-                + table
-            )
-        elif ext == ".java":
-            outline_items = parse_java_outline(lines)
-            outline_type = "java"
-            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)),
-                ),
-                ReportAction.READ,
-            )
-            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)),
-                ReportAction.READ,
-            )
-            return tr(
-                "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
-                count=len(lines),
-                outline_type=outline_type,
-            )

janito/plugins/tools/core/get_file_outline/java_outline.py

@@ -1,47 +0,0 @@
-import re
-from typing import List, Dict
-
-
-def parse_java_outline(lines: List[str]) -> List[Dict]:
-    """
-    Parses Java source code lines and extracts classes and methods with their signatures.
-    Returns a list of outline items: {type, name, return_type, parameters, generics, line}
-    """
-    outline = []
-    class_pattern = re.compile(r"\bclass\s+(\w+)(\s*<[^>]+>)?")
-    # Match methods with or without visibility modifiers (including package-private)
-    method_pattern = re.compile(
-        r"^(?:\s*(public|protected|private)\s+)?(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)"
-    )
-    current_class = None
-    for idx, line in enumerate(lines, 1):
-        class_match = class_pattern.search(line)
-        if class_match:
-            class_name = class_match.group(1)
-            generics = class_match.group(2) or ""
-            outline.append(
-                {
-                    "type": "class",
-                    "name": class_name,
-                    "generics": generics.strip("<>") if generics else None,
-                    "line": idx,
-                }
-            )
-            current_class = class_name
-        else:
-            method_match = method_pattern.search(line)
-            if method_match:
-                return_type = method_match.group(2)
-                method_name = method_match.group(3)
-                params = method_match.group(4)
-                outline.append(
-                    {
-                        "type": "method",
-                        "class": current_class,
-                        "name": method_name,
-                        "return_type": return_type,
-                        "parameters": params.strip(),
-                        "line": idx,
-                    }
-                )
-    return outline

janito/plugins/tools/core/get_file_outline/markdown_outline.py

@@ -1,14 +0,0 @@
-import re
-from typing import List
-
-
-def parse_markdown_outline(lines: List[str]):
-    header_pat = re.compile(r"^(#+)\s+(.*)")
-    outline = []
-    for idx, line in enumerate(lines):
-        match = header_pat.match(line)
-        if match:
-            level = len(match.group(1))
-            title = match.group(2).strip()
-            outline.append({"level": level, "title": title, "line": idx + 1})
-    return outline

janito/plugins/tools/core/get_file_outline/python_outline.py

@@ -1,303 +0,0 @@
-import re
-from typing import List
-
-
-def handle_assignment(idx, assign_match, outline):
-    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": "",
-            "docstring": "",
-        }
-    )
-
-
-def handle_main(idx, outline):
-    outline.append(
-        {
-            "type": "main",
-            "name": "__main__",
-            "start": idx + 1,
-            "end": idx + 1,
-            "parent": "",
-            "docstring": "",
-        }
-    )
-
-
-def close_stack_objects(idx, indent, stack, obj_ranges):
-    while stack and indent < stack[-1][2]:
-        popped = stack.pop()
-        obj_ranges.append((popped[0], popped[1], popped[3], idx, popped[4], popped[2]))
-
-
-def close_last_top_obj(idx, last_top_obj, stack, obj_ranges):
-    if last_top_obj and last_top_obj in stack:
-        stack.remove(last_top_obj)
-        obj_ranges.append(
-            (
-                last_top_obj[0],
-                last_top_obj[1],
-                last_top_obj[3],
-                idx,
-                last_top_obj[4],
-                last_top_obj[2],
-            )
-        )
-        return None
-    return last_top_obj
-
-
-def handle_class(idx, class_match, indent, stack, last_top_obj):
-    name = class_match.group(2)
-    parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
-    obj = ("class", name, indent, idx + 1, parent)
-    stack.append(obj)
-    if indent == 0:
-        last_top_obj = obj
-    return last_top_obj
-
-
-def handle_function(idx, func_match, indent, stack, last_top_obj):
-    name = func_match.group(2)
-    parent = ""
-    for s in reversed(stack):
-        if s[0] == "class" and indent > s[2]:
-            parent = s[1]
-            break
-    obj = ("function", name, indent, idx + 1, parent)
-    stack.append(obj)
-    if indent == 0:
-        last_top_obj = obj
-    return last_top_obj
-
-
-def process_line(idx, line, regexes, stack, obj_ranges, outline, last_top_obj):
-    class_pat, func_pat, assign_pat, main_pat = regexes
-    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 a new top-level class or function starts, close the previous one
-    if (class_match or func_match) and indent == 0 and last_top_obj:
-        last_top_obj = close_last_top_obj(idx, last_top_obj, stack, obj_ranges)
-    if class_match:
-        last_top_obj = handle_class(idx, class_match, indent, stack, last_top_obj)
-    elif func_match:
-        last_top_obj = handle_function(idx, func_match, indent, stack, last_top_obj)
-    elif assign_match and indent == 0:
-        handle_assignment(idx, assign_match, outline)
-    main_match = main_pat.match(line)
-    if main_match:
-        handle_main(idx, outline)
-    close_stack_objects(idx, indent, stack, obj_ranges)
-    return last_top_obj
-
-
-def extract_signature_and_decorators(lines, start_idx):
-    """
-    Extracts the signature line and leading decorators for a given function/class/method.
-    Returns (signature:str, decorators:List[str], signature_lineno:int)
-    """
-    decorators = []
-    sig_line = None
-    sig_lineno = start_idx
-    for i in range(start_idx - 1, -1, -1):
-        striped = lines[i].strip()
-        if striped.startswith("@"):
-            decorators.insert(0, striped)
-            sig_lineno = i
-        elif not striped:
-            continue
-        else:
-            break
-    # Find the signature line itself
-    for k in range(start_idx, len(lines)):
-        striped = lines[k].strip()
-        if striped.startswith("def ") or striped.startswith("class "):
-            sig_line = striped
-            sig_lineno = k
-            break
-    return sig_line, decorators, sig_lineno
-
-
-def extract_docstring(lines, start_idx, end_idx):
-    """Extracts a docstring from lines[start_idx:end_idx] if present."""
-    for i in range(start_idx, min(end_idx, len(lines))):
-        line = lines[i].lstrip()
-        if not line:
-            continue
-        if line.startswith('"""') or line.startswith("'''"):
-            quote = line[:3]
-            doc = line[3:]
-            if doc.strip().endswith(quote):
-                return doc.strip()[:-3].strip()
-            docstring_lines = [doc]
-            for j in range(i + 1, min(end_idx, len(lines))):
-                line = lines[j]
-                if line.strip().endswith(quote):
-                    docstring_lines.append(line.strip()[:-3])
-                    return "\n".join([d.strip() for d in docstring_lines]).strip()
-                docstring_lines.append(line)
-            break
-        else:
-            break
-    return ""
-
-
-def build_outline_entry(obj, lines, outline):
-    obj_type, name, start, end, parent, indent = obj
-    # Determine if this is a method
-    if obj_type == "function" and parent:
-        outline_type = "method"
-    elif obj_type == "function":
-        outline_type = "function"
-    else:
-        outline_type = obj_type
-    docstring = extract_docstring(lines, start, end)
-    outline.append(
-        {
-            "type": outline_type,
-            "name": name,
-            "start": start,
-            "end": end,
-            "parent": parent,
-            "docstring": docstring,
-        }
-    )
-
-
-def process_lines(lines, regexes):
-    outline = []
-    stack = []
-    obj_ranges = []
-    last_top_obj = None
-    for idx, line in enumerate(lines):
-        last_top_obj = process_line(
-            idx, line, regexes, stack, obj_ranges, outline, last_top_obj
-        )
-    # Close any remaining open objects
-    for popped in stack:
-        obj_ranges.append(
-            (popped[0], popped[1], popped[3], len(lines), popped[4], popped[2])
-        )
-    return outline, obj_ranges
-
-
-def build_outline(obj_ranges, lines, outline):
-    for obj in obj_ranges:
-        build_outline_entry(obj, lines, outline)
-    return outline
-
-
-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*=.*")
-    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
-    outline = []
-    stack = []
-    obj_ranges = []
-    last_top_obj = None
-    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())
-        parent = ""
-        for s in reversed(stack):
-            if s[0] == "class" and indent > s[2]:
-                parent = s[1]
-                break
-        if class_match:
-            obj = ("class", class_match.group(2), idx + 1, None, parent, indent)
-            stack.append(obj)
-            last_top_obj = obj
-        elif func_match:
-            obj = ("function", func_match.group(2), idx + 1, None, parent, indent)
-            stack.append(obj)
-            last_top_obj = obj
-        elif assign_match and indent == 0:
-            outline.append(
-                {
-                    "type": "const" if assign_match.group(2).isupper() else "var",
-                    "name": assign_match.group(2),
-                    "start": idx + 1,
-                    "end": idx + 1,
-                    "parent": "",
-                    "signature": line.strip(),
-                    "decorators": [],
-                    "docstring": "",
-                }
-            )
-        if line.strip().startswith("if __name__ == "):
-            outline.append(
-                {
-                    "type": "main",
-                    "name": "__main__",
-                    "start": idx + 1,
-                    "end": idx + 1,
-                    "parent": "",
-                    "signature": line.strip(),
-                    "decorators": [],
-                    "docstring": "",
-                }
-            )
-        # Close stack objects if indent falls back
-        while stack and indent <= stack[-1][5] and idx + 1 > stack[-1][2]:
-            finished = stack.pop()
-            outline_entry = finished[:2] + (
-                finished[2],
-                idx + 1,
-                finished[4],
-                finished[5],
-            )
-            build_outline_entry(outline_entry, lines, outline)
-    # Close any remaining objects
-    while stack:
-        finished = stack.pop()
-        outline_entry = finished[:2] + (
-            finished[2],
-            len(lines),
-            finished[4],
-            finished[5],
-        )
-        build_outline_entry(outline_entry, lines, outline)
-    return outline
-
-    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*=.*")
-    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
-    regexes = (class_pat, func_pat, assign_pat, main_pat)
-    outline, obj_ranges = process_lines(lines, regexes)
-    return build_outline(obj_ranges, lines, outline)
-
-
-def extract_docstring(lines, start_idx, end_idx):
-    """Extracts a docstring from lines[start_idx:end_idx] if present."""
-    for i in range(start_idx, min(end_idx, len(lines))):
-        line = lines[i].lstrip()
-        if not line:
-            continue
-        if line.startswith('"""') or line.startswith("'''"):
-            quote = line[:3]
-            doc = line[3:]
-            if doc.strip().endswith(quote):
-                return doc.strip()[:-3].strip()
-            docstring_lines = [doc]
-            for j in range(i + 1, min(end_idx, len(lines))):
-                line = lines[j]
-                if line.strip().endswith(quote):
-                    docstring_lines.append(line.strip()[:-3])
-                    return "\n".join([d.strip() for d in docstring_lines]).strip()
-                docstring_lines.append(line)
-            break
-        else:
-            break
-    return ""

janito/plugins/tools/core/get_file_outline/search_outline.py

@@ -1,36 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-class SearchOutlineTool(ToolBase):
-    """
-    Tool for searching outlines in files.
-
-    Args:
-        path (str): Path to the file for which to generate an outline.
-    Returns:
-        str: Outline search result or status message.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "search_outline"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        from janito.tools.tool_utils import display_path
-        from janito.i18n import tr
-
-        self.report_action(
-            tr(
-                "🔍 Searching for outline in '{disp_path}'",
-                disp_path=display_path(path),
-            ),
-            ReportAction.READ,
-        )
-        # ... rest of implementation ...
-        # Example warnings and successes:
-        # self.report_warning(tr("No files found with supported extensions."))
-        # self.report_warning(tr("Error reading {path}: {error}", path=path, error=e))
-        # self.report_success(tr("✅ {count} {match_word} found", count=len(output), match_word=pluralize('match', len(output))))
-        pass

janito/plugins/tools/core/move_file.py

@@ -1,131 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from .decorators import register_core_tool
-from janito.tools.tool_utils import display_path
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_core_tool
-class MoveFile(ToolBase):
-    """
-    Move a file or directory from src_path to dest_path.
-
-    Args:
-        src_path (str): Source file or directory path.
-        dest_path (str): Destination file or directory path.
-        overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
-        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "move_file"
-
-    def run(
-        self,
-        src_path: str,
-        dest_path: str,
-        overwrite: bool = False,
-        backup: bool = False,
-    ) -> str:
-        src = expand_path(src_path)
-        dest = expand_path(dest_path)
-        original_src = src_path
-        original_dest = dest_path
-        disp_src = display_path(original_src)
-        disp_dest = display_path(original_dest)
-        backup_path = None
-
-        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
-        if not valid:
-            return err_msg
-
-        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
-        if dest_result is not None:
-            backup_path, err_msg = dest_result
-            if err_msg:
-                return err_msg
-
-        try:
-            self.report_action(
-                tr(
-                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
-                    disp_src=disp_src,
-                    disp_dest=disp_dest,
-                ),
-                ReportAction.UPDATE,
-            )
-            shutil.move(src, dest)
-            self.report_success(tr("✅ Move complete."))
-            msg = tr("✅ Move complete.")
-
-            return msg
-        except Exception as e:
-            self.report_error(tr("❌ Error moving: {error}", error=e))
-            return tr("❌ Error moving: {error}", error=e)
-
-    def _validate_source(self, src, disp_src):
-        if not os.path.exists(src):
-            self.report_error(
-                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
-            )
-            return (
-                False,
-                False,
-                False,
-                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
-            )
-        is_src_file = os.path.isfile(src)
-        is_src_dir = os.path.isdir(src)
-        if not (is_src_file or is_src_dir):
-            self.report_error(
-                tr(
-                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
-                    disp_src=disp_src,
-                )
-            )
-            return (
-                False,
-                False,
-                False,
-                tr(
-                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
-                    disp_src=disp_src,
-                ),
-            )
-        return True, is_src_file, is_src_dir, None
-
-    def _handle_destination(self, dest, disp_dest, overwrite, backup):
-        backup_path = None
-        if os.path.exists(dest):
-            if not overwrite:
-                self.report_error(
-                    tr(
-                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
-                        disp_dest=disp_dest,
-                    ),
-                    ReportAction.UPDATE,
-                )
-                return None, tr(
-                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
-                    disp_dest=disp_dest,
-                )
-
-            try:
-                if os.path.isfile(dest):
-                    os.remove(dest)
-                elif os.path.isdir(dest):
-                    shutil.rmtree(dest)
-            except Exception as e:
-                self.report_error(
-                    tr("❌ Error removing destination before move: {error}", error=e),
-                    ReportAction.UPDATE,
-                )
-                return None, tr(
-                    "❌ Error removing destination before move: {error}", error=e
-                )
-        return backup_path, None