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

janito/{agent/tools → tools/adapters/local}/fetch_url.py

@@ -1,16 +1,17 @@
 import requests
 from bs4 import BeautifulSoup
-from janito.agent.tool_registry import register_tool
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
 from janito.i18n import tr
-from janito.agent.tools_utils.utils import pluralize
+from janito.tools.tool_utils import pluralize
 
 
-@register_tool(name="fetch_url")
+@register_local_tool
 class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
+
     Args:
         url (str): The URL of the web page to fetch.
         search_strings (list[str], optional): Strings to search for in the page content.
@@ -21,11 +22,13 @@ class FetchUrlTool(ToolBase):
             - "Warning: Empty URL provided. Operation skipped."
     """
 
+    tool_name = "fetch_url"
+
     def run(self, url: str, search_strings: list[str] = None) -> str:
         if not url.strip():
-            self.report_warning(tr("ℹ️ Empty URL provided."))
+            self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
             return tr("Warning: Empty URL provided. Operation skipped.")
-        self.report_info(ActionType.READ, tr("🌐 Fetch URL '{url}' ...", url=url))
+        self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
         try:
             response = requests.get(url, timeout=10)
             response.raise_for_status()
@@ -37,7 +40,8 @@ class FetchUrlTool(ToolBase):
                         "❗ HTTP {status_code} error for URL: {url}",
                         status_code=status_code,
                         url=url,
-                    )
+                    ),
+                    ReportAction.READ,
                 )
                 return tr(
                     "Warning: HTTP {status_code} error for URL: {url}",
@@ -50,7 +54,8 @@ class FetchUrlTool(ToolBase):
                         "❗ HTTP error for URL: {url}: {err}",
                         url=url,
                         err=str(http_err),
-                    )
+                    ),
+                    ReportAction.READ,
                 )
                 return tr(
                     "Warning: HTTP error for URL: {url}: {err}",
@@ -59,19 +64,12 @@ class FetchUrlTool(ToolBase):
                 )
         except Exception as err:
             self.report_error(
-                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err))
+                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err)),
+                ReportAction.READ,
             )
             return tr(
                 "Warning: Error fetching URL: {url}: {err}", url=url, err=str(err)
             )
-        self.update_progress(
-            {
-                "event": "progress",
-                "message": tr(
-                    "Fetched URL with status {status}", status=response.status_code
-                ),
-            }
-        )
         soup = BeautifulSoup(response.text, "html.parser")
         text = soup.get_text(separator="\n")
         if search_strings:
@@ -93,6 +91,7 @@ class FetchUrlTool(ToolBase):
                 "✅ {num_lines} {line_word}",
                 num_lines=num_lines,
                 line_word=pluralize("line", num_lines),
-            )
+            ),
+            ReportAction.READ,
         )
         return text

janito/tools/adapters/local/find_files.py

@@ -0,0 +1,140 @@
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize, display_path
+from janito.dir_walk_utils import walk_dir_with_gitignore
+from janito.i18n import tr
+import fnmatch
+import os
+
+
+@register_local_tool
+class FindFilesTool(ToolBase):
+    """
+    Find files or directories in one or more directories matching a pattern. Respects .gitignore.
+
+    If a path is an existing file, it is checked against the provided pattern(s) and included in the results if it matches. This allows find_files to be used to look for a specific set of filenames in a single call, as well as searching directories.
+
+    Args:
+        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
+        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').
+        include_gitignored (bool, optional): If True, includes files/directories ignored by .gitignore. Defaults to False.
+        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.
+    """
+
+    tool_name = "find_files"
+
+    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 _handle_file_path(self, directory, patterns):
+        dir_output = set()
+        filename = os.path.basename(directory)
+        for pat in patterns:
+            # Only match files, not directories, for file paths
+            if not (pat.endswith("/") or pat.endswith("\\")):
+                if fnmatch.fnmatch(filename, pat):
+                    dir_output.add(directory)
+                    break
+        return dir_output
+
+    def _handle_directory_path(self, directory, patterns, max_depth, include_gitignored):
+        dir_output = set()
+        for root, dirs, files in walk_dir_with_gitignore(
+            directory,
+            max_depth=max_depth,
+            include_gitignored=include_gitignored,
+        ):
+            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)
+                    )
+        return dir_output
+
+    def _report_search(self, pattern, disp_path, depth_msg):
+        self.report_action(
+            tr(
+                "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
+                pattern=pattern,
+                disp_path=disp_path,
+                depth_msg=depth_msg,
+            ),
+            ReportAction.READ,
+        )
+
+    def _report_success(self, count):
+        self.report_success(
+            tr(
+                " ✅ {count} {file_word}",
+                count=count,
+                file_word=pluralize("file", count),
+            ),
+            ReportAction.READ,
+        )
+
+    def _format_output(self, directory, dir_output):
+        if directory.strip() == ".":
+            dir_output = {
+                p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
+                for p in dir_output
+            }
+        return sorted(dir_output)
+
+    def run(
+        self,
+        paths: str,
+        pattern: str,
+        max_depth: int = None,
+        include_gitignored: bool = False,
+    ) -> str:
+        if not pattern:
+            self.report_warning(tr("ℹ️ Empty file pattern provided."), ReportAction.READ)
+            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_search(pattern, disp_path, depth_msg)
+            dir_output = set()
+            if os.path.isfile(directory):
+                dir_output = self._handle_file_path(directory, patterns)
+            elif os.path.isdir(directory):
+                dir_output = self._handle_directory_path(directory, patterns, max_depth, include_gitignored)
+            self._report_success(len(dir_output))
+            results.extend(self._format_output(directory, dir_output))
+        result = "\n".join(results)
+        return result
+

janito/tools/adapters/local/get_file_outline/core.py

@@ -0,0 +1,151 @@
+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
+import os
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.tool_utils import display_path, pluralize
+from janito.i18n import tr
+
+from janito.tools.adapters.local.adapter import register_local_tool as register_tool
+
+
+@register_tool
+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.
+    """
+
+    tool_name = "get_file_outline"
+
+    def run(self, file_path: str) -> str:
+        try:
+            self.report_action(
+                tr(
+                    "📄 Outline file '{disp_path}' ...",
+                    disp_path=display_path(file_path),
+                ),
+                ReportAction.READ,
+            )
+            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)),
+                    ),
+                    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
+                )
+            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,
+                )
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error reading file: {error}", error=e),
+                ReportAction.OUTLINE,
+            )
+            return tr("Error reading file: {error}", error=e)
+
+            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
+                )
+            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,
+                )
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error reading file: {error}", error=e),
+                ReportAction.OUTLINE,
+            )
+            return tr("Error reading file: {error}", error=e)

janito/{agent/tools → tools/adapters/local}/get_file_outline/python_outline.py

@@ -99,6 +99,57 @@ def process_line(idx, line, regexes, stack, obj_ranges, outline, last_top_obj):
     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
@@ -145,6 +196,80 @@ def build_outline(obj_ranges, lines, 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*=.*")

janito/tools/adapters/local/get_file_outline/python_outline_v2.py

@@ -0,0 +1,156 @@
+import re
+from typing import List
+
+
+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)
+    signature, decorators, signature_lineno = extract_signature_and_decorators(
+        lines, start - 1
+    )
+    outline.append(
+        {
+            "type": outline_type,
+            "name": name,
+            "start": start,
+            "end": end,
+            "parent": parent,
+            "signature": signature,
+            "decorators": decorators,
+            "docstring": docstring,
+        }
+    )
+
+
+def parse_python_outline_v2(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