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

janito/agent/tools/search_text.py

@@ -1,10 +1,11 @@
 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.tools_utils import pluralize
+from janito.agent.tools_utils.utils import pluralize
 from janito.i18n import tr
 import os
 import re
-from janito.agent.tools.gitignore_utils import filter_ignored
+from janito.agent.tools_utils.gitignore_utils import GitignoreFilter
 
 
 def is_binary_file(path, blocksize=1024):
@@ -28,11 +29,13 @@ def is_binary_file(path, blocksize=1024):
 class SearchTextTool(ToolBase):
     """
     Search for a text pattern (regex or plain string) in all files within one or more directories or file paths and return matching lines. Respects .gitignore.
-
     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): Regex pattern or plain text substring to search for in files. Tries regex first, falls back to substring if regex is invalid.
-        is_regex (bool): If True, treat pattern as regex. If False, treat as plain text. Defaults to False.
+        pattern (str): Regex pattern or plain text substring to search for in files. Must not be empty. Tries regex first, falls back to substring if regex is invalid.
+            Note: When using regex mode, special characters (such as [, ], ., *, etc.) must be escaped if you want to match them literally (e.g., use '\\[DEBUG\\]' to match the literal string '[DEBUG]').
+        is_regex (bool): If True, treat pattern as a regular expression. If False, treat as plain text (default).
+            Only set is_regex=True if your pattern is a valid regular expression. Do NOT set is_regex=True for plain text patterns, as regex special characters (such as ., *, [, ], etc.) will be interpreted and may cause unexpected results.
+            For plain text substring search, leave is_regex as False or omit it.
         max_depth (int, optional): Maximum directory depth to search. If 0 (default), search is recursive with no depth limit. If >0, limits recursion to that depth. Setting max_depth=1 disables recursion (only top-level directory). Ignored for file paths.
         max_results (int): Maximum number of results to return. 0 means no limit (default).
         ignore_utf8_errors (bool): If True, ignore utf-8 decode errors. Defaults to True.
@@ -41,20 +44,16 @@ class SearchTextTool(ToolBase):
         If max_results is reached, appends a note to the output.
     """
 
-    def run(
-        self,
-        paths: str,
-        pattern: str,
-        is_regex: bool = False,
-        max_depth: int = 0,
-        max_results: int = 0,
-        ignore_utf8_errors: bool = True,
-    ) -> str:
+    def _prepare_pattern(self, pattern, is_regex):
         if not pattern:
-            self.report_warning(
-                tr("⚠️ Warning: Empty search pattern provided. Operation skipped.")
+            self.report_error(
+                tr("Error: Empty search pattern provided. Operation aborted.")
+            )
+            return (
+                None,
+                False,
+                tr("Error: Empty search pattern provided. Operation aborted."),
             )
-            return tr("Warning: Empty search pattern provided. Operation skipped.")
         regex = None
         use_regex = False
         if is_regex:
@@ -62,14 +61,11 @@ class SearchTextTool(ToolBase):
                 regex = re.compile(pattern)
                 use_regex = True
             except re.error as e:
-                self.report_warning(
-                    tr(
-                        "Invalid regex pattern: {error}. Falling back to no results.",
-                        error=e,
-                    )
-                )
-                return tr(
-                    "Warning: Invalid regex pattern: {error}. No results.", error=e
+                self.report_warning(tr("\u26a0\ufe0f Invalid regex pattern."))
+                return (
+                    None,
+                    False,
+                    tr("Warning: Invalid regex pattern: {error}. No results.", error=e),
                 )
         else:
             try:
@@ -78,116 +74,100 @@ class SearchTextTool(ToolBase):
             except re.error:
                 regex = None
                 use_regex = False
-        output = []
-        limit_reached = False
-        total_results = 0
-        paths_list = paths.split()
-        for search_path in paths_list:
-            from janito.agent.tools.tools_utils import display_path
+        return regex, use_regex, None
 
-            info_str = tr(
-                "🔍 Searching for {search_type} '{pattern}' in '{disp_path}'",
-                search_type=("text-regex" if use_regex else "text"),
-                pattern=pattern,
-                disp_path=display_path(search_path),
-            )
-            if max_depth > 0:
-                info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
-            self.report_info(info_str)
-            dir_output = []
-            dir_limit_reached = False
-            if os.path.isfile(search_path):
-                # Handle single file
-                path = search_path
-                if not is_binary_file(path):
-                    try:
-                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
-                        if ignore_utf8_errors:
-                            open_kwargs["errors"] = "ignore"
-                        with open(path, **open_kwargs) as f:
-                            for lineno, line in enumerate(f, 1):
-                                if use_regex:
-                                    if regex.search(line):
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                else:
-                                    if pattern in line:
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                if (
-                                    max_results > 0
-                                    and (total_results + len(dir_output)) >= max_results
-                                ):
-                                    dir_limit_reached = True
-                                    break
-                    except Exception:
-                        pass
-                output.extend(dir_output)
-                total_results += len(dir_output)
-                if dir_limit_reached:
-                    limit_reached = True
-                    break
-                continue
-            # Directory logic as before
-            if max_depth == 1:
-                walk_result = next(os.walk(search_path), None)
-                if walk_result is None:
-                    walker = [(search_path, [], [])]
-                else:
-                    _, dirs, files = walk_result
-                    dirs, files = filter_ignored(search_path, dirs, files)
-                    walker = [(search_path, dirs, files)]
+    def _search_file(
+        self,
+        path,
+        pattern,
+        regex,
+        use_regex,
+        max_results,
+        total_results,
+        ignore_utf8_errors,
+    ):
+        dir_output = []
+        dir_limit_reached = False
+        if not is_binary_file(path):
+            try:
+                open_kwargs = {"mode": "r", "encoding": "utf-8"}
+                if ignore_utf8_errors:
+                    open_kwargs["errors"] = "ignore"
+                with open(path, **open_kwargs) as f:
+                    for lineno, line in enumerate(f, 1):
+                        if use_regex:
+                            if regex.search(line):
+                                dir_output.append(f"{path}:{lineno}: {line.strip()}")
+                        else:
+                            if pattern in line:
+                                dir_output.append(f"{path}:{lineno}: {line.strip()}")
+                        if (
+                            max_results > 0
+                            and (total_results + len(dir_output)) >= max_results
+                        ):
+                            dir_limit_reached = True
+                            break
+            except Exception:
+                pass
+        return dir_output, dir_limit_reached
+
+    def _search_directory(
+        self,
+        search_path,
+        pattern,
+        regex,
+        use_regex,
+        max_depth,
+        max_results,
+        total_results,
+        ignore_utf8_errors,
+    ):
+        dir_output = []
+        dir_limit_reached = False
+        if max_depth == 1:
+            walk_result = next(os.walk(search_path), None)
+            if walk_result is None:
+                walker = [(search_path, [], [])]
             else:
-                walker = os.walk(search_path)
-            stop_search = False
-            for root, dirs, files in walker:
+                _, dirs, files = walk_result
+                gitignore = GitignoreFilter()
+                dirs, files = gitignore.filter_ignored(search_path, dirs, files)
+                walker = [(search_path, dirs, files)]
+        else:
+            gitignore = GitignoreFilter()
+            walker = os.walk(search_path)
+        stop_search = False
+        for root, dirs, files in walker:
+            if stop_search:
+                break
+            rel_path = os.path.relpath(root, search_path)
+            depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+            if max_depth == 1 and depth > 0:
+                break
+            if max_depth > 0 and depth > max_depth:
+                continue
+            dirs, files = gitignore.filter_ignored(root, dirs, files)
+            for filename in files:
                 if stop_search:
                     break
-                rel_path = os.path.relpath(root, search_path)
-                depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-                if max_depth == 1 and depth > 0:
+                path = os.path.join(root, filename)
+                file_output, file_limit_reached = self._search_file(
+                    path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results + len(dir_output),
+                    ignore_utf8_errors,
+                )
+                dir_output.extend(file_output)
+                if file_limit_reached:
+                    dir_limit_reached = True
+                    stop_search = True
                     break
-                if max_depth > 0 and depth > max_depth:
-                    continue
-                dirs, files = filter_ignored(root, dirs, files)
-                for filename in files:
-                    if stop_search:
-                        break
-                    path = os.path.join(root, filename)
-                    if is_binary_file(path):
-                        continue
-                    try:
-                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
-                        if ignore_utf8_errors:
-                            open_kwargs["errors"] = "ignore"
-                        with open(path, **open_kwargs) as f:
-                            for lineno, line in enumerate(f, 1):
-                                if use_regex:
-                                    if regex.search(line):
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                else:
-                                    if pattern in line:
-                                        dir_output.append(
-                                            f"{path}:{lineno}: {line.strip()}"
-                                        )
-                                if (
-                                    max_results > 0
-                                    and (total_results + len(dir_output)) >= max_results
-                                ):
-                                    dir_limit_reached = True
-                                    stop_search = True
-                                    break
-                    except Exception:
-                        continue
-            output.extend(dir_output)
-            total_results += len(dir_output)
-            if dir_limit_reached:
-                limit_reached = True
-                break
+        return dir_output, dir_limit_reached
+
+    def _format_result(self, pattern, use_regex, output, limit_reached):
         header = tr(
             "[search_text] Pattern: '{pattern}' | Regex: {use_regex} | Results: {count}",
             pattern=pattern,
@@ -199,10 +179,76 @@ class SearchTextTool(ToolBase):
             result += tr("\n[Note: max_results limit reached, output truncated.]")
         self.report_success(
             tr(
-                " ✅ {count} {line_word} found{limit}",
+                " \u2705 {count} {line_word}{limit}",
                 count=len(output),
                 line_word=pluralize("line", len(output)),
                 limit=(" (limit reached)" if limit_reached else ""),
             )
         )
         return result
+
+    def run(
+        self,
+        paths: str,
+        pattern: str,
+        is_regex: bool = False,
+        max_depth: int = 0,
+        max_results: int = 0,
+        ignore_utf8_errors: bool = True,
+    ) -> str:
+        regex, use_regex, error_msg = self._prepare_pattern(pattern, is_regex)
+        if error_msg:
+            return error_msg
+        paths_list = paths.split()
+        results = []
+        total_results = 0
+        limit_reached = False
+        for search_path in paths_list:
+            from janito.agent.tools_utils.utils import display_path
+
+            info_str = tr(
+                "\U0001f50d Searching for {search_type} '{pattern}' in '{disp_path}'",
+                search_type=("regex" if use_regex else "text"),
+                pattern=pattern,
+                disp_path=display_path(search_path),
+            )
+            if max_depth > 0:
+                info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
+            self.report_info(ActionType.READ, info_str)
+            dir_output = []
+            dir_limit_reached = False
+            if os.path.isfile(search_path):
+                dir_output, dir_limit_reached = self._search_file(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_results,
+                    total_results,
+                    ignore_utf8_errors,
+                )
+                total_results += len(dir_output)
+                if dir_limit_reached:
+                    limit_reached = True
+            else:
+                dir_output, dir_limit_reached = self._search_directory(
+                    search_path,
+                    pattern,
+                    regex,
+                    use_regex,
+                    max_depth,
+                    max_results,
+                    total_results,
+                    ignore_utf8_errors,
+                )
+                total_results += len(dir_output)
+                if dir_limit_reached:
+                    limit_reached = True
+            # Format and append result for this path
+            result_str = self._format_result(
+                pattern, use_regex, dir_output, dir_limit_reached
+            )
+            results.append(info_str + "\n" + result_str)
+            if limit_reached:
+                break
+        return "\n\n".join(results)

janito/agent/tools/validate_file_syntax/__init__.py

@@ -0,0 +1 @@
+# Validation syntax package

janito/agent/tools/validate_file_syntax/core.py

@@ -0,0 +1,94 @@
+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
+
+from .python_validator import validate_python
+from .json_validator import validate_json
+from .yaml_validator import validate_yaml
+from .ps1_validator import validate_ps1
+from .xml_validator import validate_xml
+from .html_validator import validate_html
+from .markdown_validator import validate_markdown
+from .js_validator import validate_js
+from .css_validator import validate_css
+
+
+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()
+    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)
+        else:
+            msg = tr("⚠️ 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
+
+
+@register_tool(name="validate_file_syntax")
+class ValidateFileSyntaxTool(ToolBase):
+    """
+    Validate a file for syntax issues.
+
+    Supported types:
+      - Python (.py, .pyw)
+      - JSON (.json)
+      - YAML (.yml, .yaml)
+      - PowerShell (.ps1)
+      - XML (.xml)
+      - HTML (.html, .htm) [lxml]
+      - Markdown (.md)
+      - JavaScript (.js)
+
+    Args:
+        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>"
+    """
+
+    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),
+        )
+        result = validate_file_syntax(
+            file_path,
+            report_info=self.report_info,
+            report_warning=self.report_warning,
+            report_success=self.report_success,
+        )
+        if result.startswith("✅"):
+            self.report_success(result)
+        elif result.startswith("⚠️"):
+            self.report_warning(tr("⚠️ ") + result.lstrip("⚠️ "))
+        return result

janito/agent/tools/validate_file_syntax/css_validator.py

@@ -0,0 +1,35 @@
+from janito.i18n import tr
+import re
+
+
+def validate_css(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    # Check for unmatched curly braces
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    # Check for unclosed comments
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed comment (/* ... */)")
+    # Check for invalid property declarations (very basic)
+    for i, line in enumerate(content.splitlines(), 1):
+        # Ignore empty lines and comments
+        if not line.strip() or line.strip().startswith("/*"):
+            continue
+        # Match property: value; (allow whitespace)
+        if ":" in line and not re.search(r":.*;", line):
+            errors.append(
+                f"Line {i}: Missing semicolon after property value | {line.strip()}"
+            )
+        # Match lines with property but missing colon
+        if ";" in line and ":" not in line:
+            errors.append(
+                f"Line {i}: Missing colon in property declaration | {line.strip()}"
+            )
+    if errors:
+        msg = tr(
+            "⚠️ Warning: CSS syntax issues found:\n{errors}", errors="\n".join(errors)
+        )
+        return msg
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/html_validator.py

@@ -0,0 +1,77 @@
+from janito.i18n import tr
+import re
+from lxml import etree
+
+
+def validate_html(file_path: str) -> str:
+    warnings = []
+    with open(file_path, "r", encoding="utf-8") as f:
+        html_content = f.read()
+    script_blocks = [
+        m.span()
+        for m in re.finditer(
+            r"<script[\s\S]*?>[\s\S]*?<\/script>", html_content, re.IGNORECASE
+        )
+    ]
+    js_patterns = [
+        r"document\.addEventListener",
+        r"^\s*(var|let|const)\s+\w+\s*[=;]",
+        r"^\s*function\s+\w+\s*\(",
+        r"^\s*(const|let|var)\s+\w+\s*=\s*\(.*\)\s*=>",
+        r"^\s*window\.\w+\s*=",
+        r"^\s*\$\s*\(",
+    ]
+    for pat in js_patterns:
+        for m in re.finditer(pat, html_content):
+            in_script = False
+            for s_start, s_end in script_blocks:
+                if s_start <= m.start() < s_end:
+                    in_script = True
+                    break
+            if not in_script:
+                warnings.append(
+                    f"Line {html_content.count(chr(10), 0, m.start())+1}: JavaScript code ('{pat}') found outside <script> tag."
+                )
+    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 (
+                "mismatch" in e.message.lower()
+                or "tag not closed" in e.message.lower()
+                or "unexpected end tag" in e.message.lower()
+                or "expected" in e.message.lower()
+            ):
+                syntax_errors.append(str(e))
+        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),
+            )
+    except ImportError:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+    except Exception as e:
+        lxml_error = tr("Syntax error: {error}", error=str(e))
+    msg = ""
+    if warnings:
+        msg += (
+            tr(
+                "⚠️ Warning: JavaScript code found outside <script> tags. This is invalid HTML and will not execute in browsers.\n"
+                + "\n".join(warnings)
+            )
+            + "\n"
+        )
+    if lxml_error:
+        msg += lxml_error
+    if msg:
+        return msg.strip()
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/js_validator.py

@@ -0,0 +1,27 @@
+from janito.i18n import tr
+import re
+
+
+def validate_js(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    if content.count("(") != content.count(")"):
+        errors.append("Unmatched parentheses ( )")
+    if content.count("[") != content.count("]"):
+        errors.append("Unmatched brackets [ ]")
+    for quote in ["'", '"', "`"]:
+        unescaped = re.findall(rf"(?<!\\){quote}", content)
+        if len(unescaped) % 2 != 0:
+            errors.append(f"Unclosed string literal ({quote}) detected")
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed block comment (/* ... */)")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: JavaScript syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/json_validator.py

@@ -0,0 +1,6 @@
+def validate_json(file_path: str) -> str:
+    import json
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        json.load(f)
+    return "✅ Syntax valid"