janito 3.4.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

janito/plugins/tools/validate_file_syntax/core.py

@@ -0,0 +1,114 @@
+import os
+from janito.tools.path_utils import expand_path
+from janito.i18n import tr
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.plugins.tools.decorators import register_core_tool as register_tool
+
+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
+from .jinja2_validator import validate_jinja2
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+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,
+        ".j2": validate_jinja2,
+        ".jinja2": validate_jinja2,
+    }
+    return mapping.get(ext)
+
+
+def _handle_validation_error(e, report_warning):
+    msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
+    if report_warning:
+        report_warning(msg)
+    return msg
+
+
+def validate_file_syntax(
+    path: str, report_info=None, report_warning=None, report_success=None
+) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    validator = _get_validator(ext)
+    try:
+        if validator:
+            return validator(path)
+        else:
+            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
+            if report_warning:
+                report_warning(msg)
+            return msg
+    except Exception as e:
+        return _handle_validation_error(e, report_warning)
+
+
+class ValidateFileSyntax(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)
+      - Jinja2 templates (.j2, .jinja2)
+
+    Args:
+        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>"
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "validate_file_syntax"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr(
+                "🔎 Validate syntax for file '{disp_path}' ...",
+                disp_path=disp_path,
+            ),
+            ReportAction.READ,
+        )
+        result = validate_file_syntax(
+            path,
+            report_warning=self.report_warning,
+            report_success=self.report_success,
+        )
+        if result.startswith("✅"):
+            self.report_success(result, ReportAction.READ)
+
+        return result

janito/plugins/tools/validate_file_syntax/css_validator.py

@@ -0,0 +1,35 @@
+from janito.i18n import tr
+import re
+
+
+def validate_css(path: str) -> str:
+    with open(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 "✅ OK"

janito/plugins/tools/validate_file_syntax/html_validator.py

@@ -0,0 +1,100 @@
+from janito.i18n import tr
+import re
+
+try:
+    from lxml import etree
+except ImportError:
+    etree = None
+
+
+def validate_html(path: str) -> str:
+    html_content = _read_html_content(path)
+    warnings = _find_js_outside_script(html_content)
+    lxml_error = _parse_html_and_collect_errors(path)
+    msg = _build_result_message(warnings, lxml_error)
+    return msg
+
+
+def _read_html_content(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _find_js_outside_script(html_content):
+    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*\(",
+    ]
+    warnings = []
+    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."
+                )
+    return warnings
+
+
+def _parse_html_and_collect_errors(path):
+    lxml_error = None
+    if etree is None:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+        return lxml_error
+    try:
+        parser = etree.HTMLParser(recover=False)
+        with open(path, "rb") as f:
+            etree.parse(f, parser=parser)
+        error_log = parser.error_log
+        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:
+            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))
+    return lxml_error
+
+
+def _build_result_message(warnings, lxml_error):
+    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 "✅ OK"

janito/plugins/tools/validate_file_syntax/jinja2_validator.py

@@ -0,0 +1,50 @@
+"""Jinja2 template syntax validator."""
+
+import os
+from janito.i18n import tr
+
+
+def validate_jinja2(path: str) -> str:
+    """Validate Jinja2 template syntax."""
+    try:
+        from jinja2 import Environment, TemplateSyntaxError
+
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Create a Jinja2 environment and try to parse the template
+        env = Environment()
+        try:
+            env.parse(content)
+            return tr("✅ Syntax OK")
+        except TemplateSyntaxError as e:
+            line_num = getattr(e, "lineno", 0)
+            return tr(
+                "⚠️ Warning: Syntax error: {error} at line {line}",
+                error=str(e),
+                line=line_num,
+            )
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))
+
+    except ImportError:
+        # If jinja2 is not available, just check basic structure
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Basic checks for common Jinja2 syntax issues
+            open_tags = content.count("{%")
+            close_tags = content.count("%}")
+            open_vars = content.count("{{")
+            close_vars = content.count("}}")
+
+            if open_tags != close_tags:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 tags")
+            if open_vars != close_vars:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 variables")
+
+            return tr("✅ Syntax OK (basic validation)")
+
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))

janito/plugins/tools/validate_file_syntax/js_validator.py

@@ -0,0 +1,27 @@
+from janito.i18n import tr
+import re
+
+
+def validate_js(path: str) -> str:
+    with open(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 "✅ OK"

janito/plugins/tools/validate_file_syntax/json_validator.py

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

janito/plugins/tools/validate_file_syntax/markdown_validator.py

@@ -0,0 +1,109 @@
+from janito.i18n import tr
+import re
+
+
+def validate_markdown(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    lines = content.splitlines()
+    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()}")
+    return errors
+
+
+def _check_unclosed_code_block(content):
+    errors = []
+    if content.count("```") % 2 != 0:
+        errors.append("Unclosed code block (```) detected")
+    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()}"
+            )
+    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):
+        if _is_table_line(line):
+            continue
+        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()}"
+                )
+        if re.match(r"^\s*[-*+] ", line):
+            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 _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}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ OK"

janito/plugins/tools/validate_file_syntax/ps1_validator.py

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

janito/plugins/tools/validate_file_syntax/python_validator.py

@@ -0,0 +1,5 @@
+def validate_python(path: str) -> str:
+    import py_compile
+
+    py_compile.compile(path, doraise=True)
+    return "✅ OK"

janito/plugins/tools/validate_file_syntax/xml_validator.py

@@ -0,0 +1,11 @@
+from janito.i18n import tr
+
+
+def validate_xml(path: str) -> str:
+    try:
+        from lxml import etree
+    except ImportError:
+        return tr("⚠️ lxml not installed. Cannot validate XML.")
+    with open(path, "rb") as f:
+        etree.parse(f)
+    return "✅ OK"

janito/plugins/tools/validate_file_syntax/yaml_validator.py

@@ -0,0 +1,6 @@
+def validate_yaml(path: str) -> str:
+    import yaml
+
+    with open(path, "r", encoding="utf-8") as f:
+        yaml.safe_load(f)
+    return "✅ OK"

janito/plugins/tools/view_file.py

@@ -0,0 +1,172 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.tool_utils import pluralize
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_core_tool
+class ViewFile(ToolBase):
+    """
+    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
+
+    Args:
+        path (str): Path to the file to read lines from.
+        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
+        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
+
+    To read the full file, just provide path and leave from_line and to_line unset.
+
+    Returns:
+        str: File content with a header indicating the file name and line range. Example:
+            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
+            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
+            - "Error reading file: <error message>"
+            - "❗ not found"
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "view_file"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
+        import os
+        from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("📖 View '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
+        try:
+            if os.path.isdir(path):
+                return self._list_directory(path, disp_path)
+            lines = self._read_file_lines(path)
+            selected, selected_len, total_lines = self._select_lines(
+                lines, from_line, to_line
+            )
+            self._report_success(selected_len, from_line, to_line, total_lines)
+            header = self._format_header(
+                disp_path, from_line, to_line, selected_len, total_lines
+            )
+            return header + "".join(selected)
+        except FileNotFoundError as e:
+            self.report_warning(tr("❗ not found"))
+            return f"Error reading file: {e}"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
+
+    def _list_directory(self, path, disp_path):
+        import os
+
+        try:
+            entries = os.listdir(path)
+            entries.sort()
+            # Suffix subdirectories with '/'
+            formatted_entries = []
+            for entry in entries:
+                full_path = os.path.join(path, entry)
+                if os.path.isdir(full_path):
+                    formatted_entries.append(entry + "/")
+                else:
+                    formatted_entries.append(entry)
+            header = (
+                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
+            )
+            listing = "\n".join(formatted_entries)
+            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
+            return header + listing + "\n"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
+            return tr("Error listing directory: {error}", error=e)
+
+    def _read_file_lines(self, path):
+        """Read all lines from the file."""
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return f.readlines()
+
+    def _select_lines(self, lines, from_line, to_line):
+        """Select the requested lines and return them with their count and total lines."""
+        selected = lines[
+            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
+        ]
+        selected_len = len(selected)
+        total_lines = len(lines)
+        return selected, selected_len, total_lines
+
+    def _report_success(self, selected_len, from_line, to_line, total_lines):
+        """Report the success message after reading lines."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = to_line >= total_lines or selected_len < requested
+            if at_end:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} (end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                    )
+                )
+            elif to_line < total_lines:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} ({remaining} to end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                        remaining=total_lines - to_line,
+                    )
+                )
+        else:
+            self.report_success(
+                tr(
+                    " ✅ {selected_len} {line_word} (all)",
+                    selected_len=selected_len,
+                    line_word=pluralize("line", selected_len),
+                )
+            )
+
+    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
+        """Format the header for the output."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = selected_len < requested or to_line >= total_lines
+            if at_end:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                )
+            else:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                    total_lines=total_lines,
+                )
+        elif from_line:
+            return tr(
+                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                disp_path=disp_path,
+                from_line=from_line,
+                total_lines=total_lines,
+            )
+        else:
+            return tr(
+                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                disp_path=disp_path,
+                total_lines=total_lines,
+            )
+
+    def _handle_read_error(self, e):
+        """Handle file read errors and report appropriately."""
+        if isinstance(e, FileNotFoundError):
+            self.report_error(tr("❗ not found"), ReportAction.READ)
+            return tr("❗ not found")
+        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
+        return tr("Error reading file: {error}", error=e)

janito/plugins/ui/__init__.py

@@ -0,0 +1,7 @@
+"""
+User Interface Plugin Package
+
+Contains user interaction and interface tools.
+"""
+
+__all__ = ["userinterface"]