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

janito/agent/tools/search_text/traverse_directory.py

@@ -0,0 +1,127 @@
+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):
+    return [d for d in dirs if 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

@@ -1,6 +1,7 @@
 import os
 from janito.i18n import tr
 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 display_path
 
@@ -15,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")
@@ -69,15 +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(
-            tr("🔎 Validating syntax for file '{disp_path}' ...", disp_path=disp_path)
+            ActionType.READ,
+            tr(
+                "\U0001f50e Validate syntax for file '{disp_path}' ...",
+                disp_path=disp_path,
+            ),
         )
         result = validate_file_syntax(
             file_path,
@@ -85,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/action_type.py

@@ -0,0 +1,7 @@
+from enum import Enum, auto
+
+
+class ActionType(Enum):
+    READ = auto()
+    WRITE = auto()
+    EXECUTE = auto()

janito/agent/tools_utils/dir_walk_utils.py

@@ -1,5 +1,5 @@
 import os
-from .gitignore_utils import filter_ignored
+from .gitignore_utils import GitignoreFilter
 
 
 def walk_dir_with_gitignore(root_dir, max_depth=None):
@@ -11,6 +11,7 @@ def walk_dir_with_gitignore(root_dir, max_depth=None):
     - If max_depth=1, only the root directory (matches 'find . -maxdepth 1').
     - If max_depth=N (N>1), yields files in root and up to N-1 levels below root (matches 'find . -maxdepth N').
     """
+    gitignore = GitignoreFilter()
     for root, dirs, files in os.walk(root_dir):
         rel_path = os.path.relpath(root, root_dir)
         depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
@@ -19,5 +20,5 @@ def walk_dir_with_gitignore(root_dir, max_depth=None):
                 # For max_depth=1, only root (depth=0). For max_depth=2, root and one level below (depth=0,1).
                 if depth > 0:
                     continue
-        dirs, files = filter_ignored(root, dirs, files)
+        dirs, files = gitignore.filter_ignored(root, dirs, files)
         yield root, dirs, files

janito/agent/tools_utils/formatting.py

@@ -1,23 +1,49 @@
-def format_outline_table(outline_items):
-    if not outline_items:
-        return "No classes, functions, or variables found."
-    header = "| Type    | Name        | Start | End | Parent   | Docstring                |\n|---------|-------------|-------|-----|----------|--------------------------|"
-    rows = []
-    for item in outline_items:
-        docstring = item.get("docstring", "").replace("\n", " ")
-        if len(docstring) > 24:
-            docstring = docstring[:21] + "..."
-        rows.append(
-            f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
-        )
-    return header + "\n" + "\n".join(rows)
+class OutlineFormatter:
+    """
+    Utility class for formatting code and markdown outlines into human-readable tables.
+    """
 
+    @staticmethod
+    def format_outline_table(outline_items):
+        """
+        Format a list of code outline items (classes, functions, variables) into a table.
 
-def format_markdown_outline_table(outline_items):
-    if not outline_items:
-        return "No headers found."
-    header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
-    rows = []
-    for item in outline_items:
-        rows.append(f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |")
-    return header + "\n" + "\n".join(rows)
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'type', 'name', 'start', 'end', 'parent', 'docstring'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No classes, functions, or variables found."
+        header = "| Type    | Name        | Start | End | Parent   | Docstring                |\n|---------|-------------|-------|-----|----------|--------------------------|"
+        rows = []
+        for item in outline_items:
+            docstring = item.get("docstring", "").replace("\n", " ")
+            if len(docstring) > 24:
+                docstring = docstring[:21] + "..."
+            rows.append(
+                f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} | {docstring:<24} |"
+            )
+        return header + "\n" + "\n".join(rows)
+
+    @staticmethod
+    def format_markdown_outline_table(outline_items):
+        """
+        Format a list of markdown outline items (headers) into a table.
+
+        Args:
+            outline_items (list of dict): Each dict should contain keys: 'level', 'title', 'line'.
+
+        Returns:
+            str: Formatted table as a string.
+        """
+        if not outline_items:
+            return "No headers found."
+        header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
+        rows = []
+        for item in outline_items:
+            rows.append(
+                f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |"
+            )
+        return header + "\n" + "\n".join(rows)