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

janito/agent/tools/find_files.py

@@ -1,4 +1,5 @@
 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
@@ -24,6 +25,26 @@ class FindFilesTool(ToolBase):
             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) -> str:
         if not pattern:
             self.report_warning(tr("ℹ️ Empty file pattern provided."))
@@ -38,31 +59,26 @@ class FindFilesTool(ToolBase):
                 else ""
             )
             self.report_info(
+                ActionType.READ,
                 tr(
-                    "🔍 Searching for files '{pattern}' in '{disp_path}'{depth_msg} ...",
+                    "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
                     pattern=pattern,
                     disp_path=disp_path,
                     depth_msg=depth_msg,
-                )
+                ),
             )
             dir_output = set()
             for root, dirs, files in walk_dir_with_gitignore(
                 directory, max_depth=max_depth
             ):
                 for pat in patterns:
-                    # Directory matching: pattern ends with '/' or '\'
                     if pat.endswith("/") or pat.endswith("\\"):
-                        dir_pat = pat.rstrip("/\\")
-                        for d in dirs:
-                            if fnmatch.fnmatch(d, dir_pat):
-                                dir_output.add(os.path.join(root, d) + os.sep)
+                        dir_output.update(self._match_directories(root, dirs, pat))
                     else:
-                        # Match files
-                        for filename in fnmatch.filter(files, pat):
-                            dir_output.add(os.path.join(root, filename))
-                        # Also match directories (without trailing slash)
-                        for d in fnmatch.filter(dirs, pat):
-                            dir_output.add(os.path.join(root, d))
+                        dir_output.update(self._match_files(root, files, pat))
+                        dir_output.update(
+                            self._match_dirs_without_slash(root, dirs, pat)
+                        )
             self.report_success(
                 tr(
                     " ✅ {count} {file_word}",
@@ -70,7 +86,6 @@ class FindFilesTool(ToolBase):
                     file_word=pluralize("file", len(dir_output)),
                 )
             )
-            # If searching in '.', strip leading './' from results
             if directory.strip() == ".":
                 dir_output = {
                     p[2:] if (p.startswith("./") or p.startswith(".\\")) else p

janito/agent/tools/get_file_outline/core.py

@@ -1,12 +1,10 @@
 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 (
-    format_outline_table,
-    format_markdown_outline_table,
-)
+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
 
@@ -23,10 +21,11 @@ class GetFileOutlineTool(ToolBase):
     def run(self, file_path: str) -> str:
         try:
             self.report_info(
+                ActionType.READ,
                 tr(
-                    "📄 Outlining file '{disp_path}' ...",
+                    "📄 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:
@@ -34,7 +33,7 @@ class GetFileOutlineTool(ToolBase):
             if ext == ".py":
                 outline_items = parse_python_outline(lines)
                 outline_type = "python"
-                table = format_outline_table(outline_items)
+                table = OutlineFormatter.format_outline_table(outline_items)
                 self.report_success(
                     tr(
                         "✅ Outlined {count} {item_word}",
@@ -53,7 +52,7 @@ class GetFileOutlineTool(ToolBase):
             elif ext == ".md":
                 outline_items = parse_markdown_outline(lines)
                 outline_type = "markdown"
-                table = format_markdown_outline_table(outline_items)
+                table = OutlineFormatter.format_markdown_outline_table(outline_items)
                 self.report_success(
                     tr(
                         "✅ Outlined {count} {item_word}",

janito/agent/tools/get_file_outline/python_outline.py

@@ -2,114 +2,158 @@ 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*=.*")
-    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+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 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 = []  # (type, name, indent, start, parent)
-    obj_ranges = []  # (type, name, start, end, parent, indent)
+    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())
-        # 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:
-            # Only close if still open
-            if 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],
-                    )
-                )
-            last_top_obj = None
-        if class_match:
-            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
-        elif func_match:
-            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
-        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": "",
-                    "docstring": "",
-                }
-            )
-        main_match = main_pat.match(line)
-        if main_match:
-            outline.append(
-                {
-                    "type": "main",
-                    "name": "__main__",
-                    "start": idx + 1,
-                    "end": idx + 1,
-                    "parent": "",
-                    "docstring": "",
-                }
-            )
-        while stack and indent < stack[-1][2]:
-            popped = stack.pop()
-            obj_ranges.append(
-                (popped[0], popped[1], popped[3], idx, popped[4], popped[2])
-            )
+        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
+
 
-    # Now, extract docstrings for classes, functions, and methods
+def build_outline(obj_ranges, lines, outline):
     for obj in obj_ranges:
-        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,
-            }
-        )
+        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*:")
+    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))):

janito/agent/tools/get_file_outline/search_outline.py

@@ -1,4 +1,5 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 
 
@@ -13,10 +14,11 @@ class SearchOutlineTool(ToolBase):
         from janito.i18n import tr
 
         self.report_info(
+            ActionType.READ,
             tr(
                 "🔍 Searching for outline in '{disp_path}'",
                 disp_path=display_path(file_path),
-            )
+            ),
         )
         # ... rest of implementation ...
         # Example warnings and successes:

janito/agent/tools/get_lines.py

@@ -1,4 +1,5 @@
 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
 from janito.i18n import tr
@@ -21,95 +22,128 @@ class GetLinesTool(ToolBase):
             - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
             - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
             - "Error reading file: <error message>"
-            - "❗ not found"
+            - "\u2757 not found"
     """
 
     def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
         from janito.agent.tools_utils.utils import display_path
 
         disp_path = display_path(file_path)
+        self._report_read_info(disp_path, from_line, to_line)
+        try:
+            lines = self._read_file_lines(file_path)
+            selected, selected_len, total_lines = self._select_lines(
+                lines, from_line, to_line
+            )
+            self._report_success(selected_len, from_line, to_line, total_lines)
+            header = self._format_header(
+                disp_path, from_line, to_line, selected_len, total_lines
+            )
+            return header + "".join(selected)
+        except Exception as e:
+            return self._handle_read_error(e)
+
+    def _report_read_info(self, disp_path, from_line, to_line):
+        """Report the info message for reading lines."""
         if from_line and to_line:
             self.report_info(
+                ActionType.READ,
                 tr(
-                    "📖 Reading file '{disp_path}' {from_line}-{to_line}",
+                    "📖 Read file '{disp_path}' {from_line}-{to_line}",
                     disp_path=disp_path,
                     from_line=from_line,
                     to_line=to_line,
-                )
+                ),
             )
         else:
-            self.report_info(tr("📖 Reading file '{disp_path}'", disp_path=disp_path))
-        try:
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                lines = f.readlines()
-            selected = lines[
-                (from_line - 1 if from_line else 0) : (to_line if to_line else None)
-            ]
-            selected_len = len(selected)
-            total_lines = len(lines)
-            at_end = False
-            if from_line and to_line:
-                requested = to_line - from_line + 1
-                if to_line >= total_lines or selected_len < requested:
-                    at_end = True
-                if at_end:
-                    self.report_success(
-                        tr(
-                            " ✅ {selected_len} {line_word} (end)",
-                            selected_len=selected_len,
-                            line_word=pluralize("line", selected_len),
-                        )
-                    )
-                elif to_line < total_lines:
-                    self.report_success(
-                        tr(
-                            " ✅ {selected_len} {line_word} ({remaining} to end)",
-                            selected_len=selected_len,
-                            line_word=pluralize("line", selected_len),
-                            remaining=total_lines - to_line,
-                        )
-                    )
-            else:
+            self.report_info(
+                ActionType.READ,
+                tr("📖 Read file '{disp_path}'", disp_path=disp_path),
+            )
+
+    def _read_file_lines(self, file_path):
+        """Read all lines from the file."""
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            return f.readlines()
+
+    def _select_lines(self, lines, from_line, to_line):
+        """Select the requested lines and return them with their count and total lines."""
+        selected = lines[
+            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
+        ]
+        selected_len = len(selected)
+        total_lines = len(lines)
+        return selected, selected_len, total_lines
+
+    def _report_success(self, selected_len, from_line, to_line, total_lines):
+        """Report the success message after reading lines."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = to_line >= total_lines or selected_len < requested
+            if at_end:
                 self.report_success(
                     tr(
-                        " ✅ {selected_len} {line_word} (all)",
+                        " \u2705 {selected_len} {line_word} (end)",
                         selected_len=selected_len,
                         line_word=pluralize("line", selected_len),
                     )
                 )
-            if from_line and to_line:
-                if to_line >= total_lines or selected_len < (to_line - from_line + 1):
-                    header = tr(
-                        "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
-                        disp_path=disp_path,
-                        from_line=from_line,
-                        to_line=to_line,
-                    )
-                else:
-                    header = tr(
-                        "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
-                        disp_path=disp_path,
-                        from_line=from_line,
-                        to_line=to_line,
-                        total_lines=total_lines,
+            elif to_line < total_lines:
+                self.report_success(
+                    tr(
+                        " \u2705 {selected_len} {line_word} ({remaining} to end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                        remaining=total_lines - to_line,
                     )
-            elif from_line:
-                header = tr(
-                    "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                )
+        else:
+            self.report_success(
+                tr(
+                    " \u2705 {selected_len} {line_word} (all)",
+                    selected_len=selected_len,
+                    line_word=pluralize("line", selected_len),
+                )
+            )
+
+    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
+        """Format the header for the output."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = selected_len < requested or to_line >= total_lines
+            if at_end:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
                     disp_path=disp_path,
                     from_line=from_line,
-                    total_lines=total_lines,
+                    to_line=to_line,
                 )
             else:
-                header = tr(
-                    "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
                     disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
                     total_lines=total_lines,
                 )
-            return header + "".join(selected)
-        except Exception as e:
-            if isinstance(e, FileNotFoundError):
-                self.report_error(tr("❗ not found"))
-                return tr("❗ not found")
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)
+        elif from_line:
+            return tr(
+                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                disp_path=disp_path,
+                from_line=from_line,
+                total_lines=total_lines,
+            )
+        else:
+            return tr(
+                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                disp_path=disp_path,
+                total_lines=total_lines,
+            )
+
+    def _handle_read_error(self, e):
+        """Handle file read errors and report appropriately."""
+        if isinstance(e, FileNotFoundError):
+            self.report_error(tr("\u2757 not found"))
+            return tr("\u2757 not found")
+        self.report_error(tr(" \u274c Error: {error}", error=e))
+        return tr("Error reading file: {error}", error=e)