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

janito/agent/tools/search_text/pattern_utils.py

@@ -0,0 +1,65 @@
+import re
+from janito.i18n import tr
+from janito.agent.tools_utils.utils import pluralize
+
+
+def prepare_pattern(pattern, is_regex, report_error, report_warning):
+    if not pattern:
+        report_error(tr("Error: Empty search pattern provided. Operation aborted."))
+        return (
+            None,
+            False,
+            tr("Error: Empty search pattern provided. Operation aborted."),
+        )
+    regex = None
+    use_regex = False
+    if is_regex:
+        try:
+            regex = re.compile(pattern)
+            use_regex = True
+        except re.error as e:
+            report_warning(tr("\u26a0\ufe0f Invalid regex pattern."))
+            return (
+                None,
+                False,
+                tr(
+                    "Error: Invalid regex pattern: {error}. Operation aborted.", error=e
+                ),
+            )
+    else:
+        # Do not compile as regex if is_regex is False; treat as plain text
+        regex = None
+        use_regex = False
+    return regex, use_regex, None
+
+
+def format_result(
+    pattern, use_regex, output, limit_reached, count_only=False, per_file_counts=None
+):
+    # Ensure output is always a list for joining
+    if output is None or not isinstance(output, (list, tuple)):
+        output = []
+    if count_only:
+        lines = []
+        total = 0
+        if per_file_counts:
+            for file_path, count in per_file_counts:
+                lines.append(f"{file_path}: {count}")
+                total += count
+        lines.append(f"Total matches: {total}")
+        if limit_reached:
+            lines.append(tr("[Max results reached. Output truncated.]"))
+        return "\n".join(lines)
+    else:
+        if not output:
+            return tr("No matches found.")
+        result = "\n".join(output)
+        if limit_reached:
+            result += tr("\n[Max results reached. Output truncated.]")
+        return result
+
+
+def summarize_total(all_per_file_counts):
+    total = sum(count for _, count in all_per_file_counts)
+    summary = f"\nGrand total matches: {total}"
+    return summary

janito/agent/tools/search_text/traverse_directory.py

@@ -0,0 +1,132 @@
+import os
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
+from .match_lines import match_line, should_limit, read_file_lines
+
+
+def walk_directory(search_path, max_depth):
+    if max_depth == 1:
+        walk_result = next(os.walk(search_path), None)
+        if walk_result is None:
+            return [(search_path, [], [])]
+        else:
+            return [walk_result]
+    else:
+        return os.walk(search_path)
+
+
+def filter_dirs(dirs, root, gitignore_filter):
+    # Always exclude directories named .git, regardless of gitignore
+    return [
+        d
+        for d in dirs
+        if d != ".git" and not gitignore_filter.is_ignored(os.path.join(root, d))
+    ]
+
+
+def process_file_count_only(
+    file_path, per_file_counts, pattern, regex, use_regex, max_results, total_results
+):
+    match_count, file_limit_reached, _ = read_file_lines(
+        file_path,
+        pattern,
+        regex,
+        use_regex,
+        True,
+        max_results,
+        total_results + sum(count for _, count in per_file_counts),
+    )
+    if match_count > 0:
+        per_file_counts.append((file_path, match_count))
+    return file_limit_reached
+
+
+def process_file_collect(
+    file_path,
+    dir_output,
+    per_file_counts,
+    pattern,
+    regex,
+    use_regex,
+    max_results,
+    total_results,
+):
+    actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
+        file_path,
+        pattern,
+        regex,
+        use_regex,
+        False,
+        max_results,
+        total_results + len(dir_output),
+    )
+    dir_output.extend(file_lines_output)
+    if actual_match_count > 0:
+        per_file_counts.append((file_path, actual_match_count))
+    return file_limit_reached
+
+
+def should_limit_depth(root, search_path, max_depth, dirs):
+    if max_depth > 0:
+        rel_root = os.path.relpath(root, search_path)
+        if rel_root != ".":
+            depth = rel_root.count(os.sep) + 1
+            if depth >= max_depth:
+                del dirs[:]
+
+
+def traverse_directory(
+    search_path,
+    pattern,
+    regex,
+    use_regex,
+    max_depth,
+    max_results,
+    total_results,
+    count_only,
+):
+    dir_output = []
+    dir_limit_reached = False
+    per_file_counts = []
+    walker = walk_directory(search_path, max_depth)
+    gitignore_filter = GitignoreFilter(search_path)
+
+    for root, dirs, files in walker:
+        dirs[:] = filter_dirs(dirs, root, gitignore_filter)
+        for file in files:
+            file_path = os.path.join(root, file)
+            if gitignore_filter.is_ignored(file_path):
+                continue
+            if count_only:
+                file_limit_reached = process_file_count_only(
+                    file_path,
+                    per_file_counts,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+            else:
+                file_limit_reached = process_file_collect(
+                    file_path,
+                    dir_output,
+                    per_file_counts,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results,
+                )
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    break
+        if dir_limit_reached:
+            break
+        should_limit_depth(root, search_path, max_depth, dirs)
+    if count_only:
+        return per_file_counts, dir_limit_reached, []
+    else:
+        return dir_output, dir_limit_reached, per_file_counts

janito/agent/tools/validate_file_syntax/core.py

@@ -16,39 +16,47 @@ from .js_validator import validate_js
 from .css_validator import validate_css
 
 
+def _get_validator(ext):
+    """Return the appropriate validator function for the file extension."""
+    mapping = {
+        ".py": validate_python,
+        ".pyw": validate_python,
+        ".json": validate_json,
+        ".yml": validate_yaml,
+        ".yaml": validate_yaml,
+        ".ps1": validate_ps1,
+        ".xml": validate_xml,
+        ".html": validate_html,
+        ".htm": validate_html,
+        ".md": validate_markdown,
+        ".js": validate_js,
+        ".css": validate_css,
+    }
+    return mapping.get(ext)
+
+
+def _handle_validation_error(e, report_warning):
+    msg = tr("\u26a0\ufe0f Warning: Syntax error: {error}", error=e)
+    if report_warning:
+        report_warning(msg)
+    return msg
+
+
 def validate_file_syntax(
     file_path: str, report_info=None, report_warning=None, report_success=None
 ) -> str:
     ext = os.path.splitext(file_path)[1].lower()
+    validator = _get_validator(ext)
     try:
-        if ext in [".py", ".pyw"]:
-            return validate_python(file_path)
-        elif ext == ".json":
-            return validate_json(file_path)
-        elif ext in [".yml", ".yaml"]:
-            return validate_yaml(file_path)
-        elif ext == ".ps1":
-            return validate_ps1(file_path)
-        elif ext == ".xml":
-            return validate_xml(file_path)
-        elif ext in (".html", ".htm"):
-            return validate_html(file_path)
-        elif ext == ".md":
-            return validate_markdown(file_path)
-        elif ext == ".js":
-            return validate_js(file_path)
-        elif ext == ".css":
-            return validate_css(file_path)
+        if validator:
+            return validator(file_path)
         else:
-            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
+            msg = tr("\u26a0\ufe0f Warning: Unsupported file extension: {ext}", ext=ext)
             if report_warning:
                 report_warning(msg)
             return msg
     except Exception as e:
-        msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
-        if report_warning:
-            report_warning(msg)
-        return msg
+        return _handle_validation_error(e, report_warning)
 
 
 @register_tool(name="validate_file_syntax")
@@ -70,16 +78,19 @@ class ValidateFileSyntaxTool(ToolBase):
         file_path (str): Path to the file to validate.
     Returns:
         str: Validation status message. Example:
-            - "✅ Syntax OK"
-            - "⚠️ Warning: Syntax error: <error message>"
-            - "⚠️ Warning: Unsupported file extension: <ext>"
+            - "\u2705 Syntax OK"
+            - "\u26a0\ufe0f Warning: Syntax error: <error message>"
+            - "\u26a0\ufe0f Warning: Unsupported file extension: <ext>"
     """
 
     def run(self, file_path: str) -> str:
         disp_path = display_path(file_path)
         self.report_info(
             ActionType.READ,
-            tr("🔎 Validating syntax for file '{disp_path}' ...", disp_path=disp_path),
+            tr(
+                "\U0001f50e Validate syntax for file '{disp_path}' ...",
+                disp_path=disp_path,
+            ),
         )
         result = validate_file_syntax(
             file_path,
@@ -87,8 +98,8 @@ class ValidateFileSyntaxTool(ToolBase):
             report_warning=self.report_warning,
             report_success=self.report_success,
         )
-        if result.startswith("✅"):
+        if result.startswith("\u2705"):
             self.report_success(result)
-        elif result.startswith("⚠️"):
-            self.report_warning(tr("⚠️ ") + result.lstrip("⚠️ "))
+        elif result.startswith("\u26a0\ufe0f"):
+            self.report_warning(tr("\u26a0\ufe0f ") + result.lstrip("\u26a0\ufe0f "))
         return result

janito/agent/tools/validate_file_syntax/html_validator.py

@@ -4,9 +4,19 @@ from lxml import etree
 
 
 def validate_html(file_path: str) -> str:
-    warnings = []
+    html_content = _read_html_content(file_path)
+    warnings = _find_js_outside_script(html_content)
+    lxml_error = _parse_html_and_collect_errors(file_path)
+    msg = _build_result_message(warnings, lxml_error)
+    return msg
+
+
+def _read_html_content(file_path):
     with open(file_path, "r", encoding="utf-8") as f:
-        html_content = f.read()
+        return f.read()
+
+
+def _find_js_outside_script(html_content):
     script_blocks = [
         m.span()
         for m in re.finditer(
@@ -21,6 +31,7 @@ def validate_html(file_path: str) -> str:
         r"^\s*window\.\w+\s*=",
         r"^\s*\$\s*\(",
     ]
+    warnings = []
     for pat in js_patterns:
         for m in re.finditer(pat, html_content):
             in_script = False
@@ -32,14 +43,16 @@ def validate_html(file_path: str) -> str:
                 warnings.append(
                     f"Line {html_content.count(chr(10), 0, m.start())+1}: JavaScript code ('{pat}') found outside <script> tag."
                 )
+    return warnings
+
+
+def _parse_html_and_collect_errors(file_path):
     lxml_error = None
     try:
-        # Parse HTML and collect error log
         parser = etree.HTMLParser(recover=False)
         with open(file_path, "rb") as f:
             etree.parse(f, parser=parser)
         error_log = parser.error_log
-        # Look for tag mismatch or unclosed tag errors
         syntax_errors = []
         for e in error_log:
             if (
@@ -52,7 +65,6 @@ def validate_html(file_path: str) -> str:
         if syntax_errors:
             lxml_error = tr("Syntax error: {error}", error="; ".join(syntax_errors))
         elif error_log:
-            # Other warnings
             lxml_error = tr(
                 "HTML syntax errors found:\n{errors}",
                 errors="\n".join(str(e) for e in error_log),
@@ -61,6 +73,10 @@ def validate_html(file_path: str) -> str:
         lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
     except Exception as e:
         lxml_error = tr("Syntax error: {error}", error=str(e))
+    return lxml_error
+
+
+def _build_result_message(warnings, lxml_error):
     msg = ""
     if warnings:
         msg += (

janito/agent/tools/validate_file_syntax/markdown_validator.py

@@ -5,62 +5,105 @@ import re
 def validate_markdown(file_path: str) -> str:
     with open(file_path, "r", encoding="utf-8") as f:
         content = f.read()
-    errors = []
     lines = content.splitlines()
-    # Header space check
+    errors = []
+    errors.extend(_check_header_space(lines))
+    errors.extend(_check_unclosed_code_block(content))
+    errors.extend(_check_unclosed_links_images(lines))
+    errors.extend(_check_list_formatting(lines))
+    errors.extend(_check_unclosed_inline_code(content))
+    return _build_markdown_result(errors)
+
+
+def _check_header_space(lines):
+    errors = []
     for i, line in enumerate(lines, 1):
         if re.match(r"^#+[^ #]", line):
             errors.append(f"Line {i}: Header missing space after # | {line.strip()}")
-    # Unclosed code block
+    return errors
+
+
+def _check_unclosed_code_block(content):
+    errors = []
     if content.count("```") % 2 != 0:
         errors.append("Unclosed code block (```) detected")
-    # Unclosed link or image
+    return errors
+
+
+def _check_unclosed_links_images(lines):
+    errors = []
     for i, line in enumerate(lines, 1):
         if re.search(r"\[[^\]]*\]\([^)]+$", line):
             errors.append(
                 f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
             )
-    # List item formatting and blank line before new list (bulleted and numbered)
+    return errors
+
+
+def _is_table_line(line):
+    return line.lstrip().startswith("|")
+
+
+def _list_item_missing_space(line):
+    return re.match(r"^[-*+][^ \n]", line)
+
+
+def _should_skip_list_item(line):
+    stripped = line.strip()
+    return stripped.startswith("*") and stripped.endswith("*") and len(stripped) > 2
+
+
+def _needs_blank_line_before_bullet(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
+    return not prev_is_list and prev_line.strip() != ""
+
+
+def _needs_blank_line_before_numbered(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
+    return not prev_is_numbered_list and prev_line.strip() != ""
+
+
+def _check_list_formatting(lines):
+    errors = []
     for i, line in enumerate(lines, 1):
-        # Skip table lines
-        if line.lstrip().startswith("|"):
+        if _is_table_line(line):
             continue
-        # List item missing space after bullet
-        if re.match(r"^[-*+][^ \n]", line):
-            stripped = line.strip()
-            if not (
-                stripped.startswith("*")
-                and stripped.endswith("*")
-                and len(stripped) > 2
-            ):
+        if _list_item_missing_space(line):
+            if not _should_skip_list_item(line):
                 errors.append(
                     f"Line {i}: List item missing space after bullet | {line.strip()}"
                 )
-        # Blank line before first item of a new bulleted list
         if re.match(r"^\s*[-*+] ", line):
-            if i > 1:
-                prev_line = lines[i - 2]
-                prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
-                if not prev_is_list and prev_line.strip() != "":
-                    errors.append(
-                        f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
-                    )
-        # Blank line before first item of a new numbered list
+            if _needs_blank_line_before_bullet(lines, i):
+                errors.append(
+                    f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
         if re.match(r"^\s*\d+\. ", line):
-            if i > 1:
-                prev_line = lines[i - 2]
-                prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
-                if not prev_is_numbered_list and prev_line.strip() != "":
-                    errors.append(
-                        f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
-                    )
-    # Unclosed inline code
+            if _needs_blank_line_before_numbered(lines, i):
+                errors.append(
+                    f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
+    return errors
+
+
+def _check_unclosed_inline_code(content):
+    errors = []
     if content.count("`") % 2 != 0:
         errors.append("Unclosed inline code (`) detected")
+    return errors
+
+
+def _build_markdown_result(errors):
     if errors:
         msg = tr(
-            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
+            "\u26a0\ufe0f Warning: Markdown syntax issues found:\n{errors}",
             errors="\n".join(errors),
         )
         return msg
-    return "✅ Syntax valid"
+    return "\u2705 Syntax valid"

janito/agent/tools_utils/gitignore_utils.py

@@ -9,7 +9,7 @@ class GitignoreFilter:
     Methods
     -------
     __init__(self, gitignore_path: str = ".gitignore")
-        Loads and parses .gitignore patterns from the specified path.
+        Loads and parses .gitignore patterns from the specified path or finds the nearest .gitignore if a directory is given.
 
     is_ignored(self, path: str) -> bool
         Returns True if the given path matches any of the loaded .gitignore patterns.
@@ -18,8 +18,31 @@ class GitignoreFilter:
         Filters out ignored directories and files from the provided lists, returning only those not ignored.
     """
 
+    @staticmethod
+    def find_nearest_gitignore(start_path):
+        """
+        Search upward from start_path for the nearest .gitignore file.
+        Returns the path to the found .gitignore, or the default .gitignore in start_path if none found.
+        """
+        current_dir = os.path.abspath(start_path)
+        if os.path.isfile(current_dir):
+            current_dir = os.path.dirname(current_dir)
+        while True:
+            candidate = os.path.join(current_dir, ".gitignore")
+            if os.path.isfile(candidate):
+                return candidate
+            parent = os.path.dirname(current_dir)
+            if parent == current_dir:
+                # Reached filesystem root, return default .gitignore path (may not exist)
+                return os.path.join(start_path, ".gitignore")
+            current_dir = parent
+
     def __init__(self, gitignore_path: str = ".gitignore"):
-        self.gitignore_path = os.path.abspath(gitignore_path)
+        # If a directory is passed, find the nearest .gitignore up the tree
+        if os.path.isdir(gitignore_path):
+            self.gitignore_path = self.find_nearest_gitignore(gitignore_path)
+        else:
+            self.gitignore_path = os.path.abspath(gitignore_path)
         self.base_dir = os.path.dirname(self.gitignore_path)
         lines = []
         if not os.path.exists(self.gitignore_path):

janito/agent/tools_utils/utils.py

@@ -12,7 +12,13 @@ def display_path(path):
         str: Display path, optionally as an ANSI hyperlink.
     """
     if os.path.isabs(path):
-        disp = path
+        cwd = os.path.abspath(os.getcwd())
+        abs_path = os.path.abspath(path)
+        # Check if the absolute path is within the current working directory
+        if abs_path.startswith(cwd + os.sep):
+            disp = os.path.relpath(abs_path, cwd)
+        else:
+            disp = path
     else:
         disp = os.path.relpath(path)
     port = runtime_config.get("termweb_port")