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

janito/plugins_backup_20250825_070018/core/filemanager/tools/replace_text_in_file.py

@@ -1,270 +0,0 @@
-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.i18n import tr
-import shutil
-import re
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
-
-
-@register_local_tool
-class ReplaceTextInFileTool(ToolBase):
-    """
-    Replace exact occurrences of a given text in a file.
-
-    Note:
-        To avoid syntax errors, ensure your replacement text is pre-indented as needed, matching the indentation of the
-        search text in its original location.
-
-    Args:
-        path (str): Path to the file to modify.
-        search_text (str): The exact text to search for (including indentation).
-        replacement_text (str): The text to replace with (including indentation).
-        replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
-        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
-    Returns:
-        str: Status message. Example:
-            - "Text replaced in /path/to/file"
-            - "No changes made. [Warning: Search text not found in file] Please review the original file."
-            - "Error replacing text: <error message>"
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "replace_text_in_file"
-
-    def run(
-        self,
-        path: str,
-        search_text: str,
-        replacement_text: str,
-        replace_all: bool = False,
-        backup: bool = False,
-    ) -> str:
-        from janito.tools.tool_utils import display_path
-
-        disp_path = display_path(path)
-        action = "(all)" if replace_all else ""
-        search_lines = len(search_text.splitlines())
-        replace_lines = len(replacement_text.splitlines())
-        info_msg = self._format_info_msg(
-            disp_path,
-            search_lines,
-            replace_lines,
-            action,
-            search_text,
-            replacement_text,
-            path,
-        )
-        self.report_action(info_msg, ReportAction.CREATE)
-        try:
-            content = self._read_file_content(path)
-            match_lines = self._find_match_lines(content, search_text)
-            occurrences = content.count(search_text)
-            replaced_count, new_content = self._replace_content(
-                content, search_text, replacement_text, replace_all, occurrences
-            )
-            file_changed = new_content != content
-            backup_path = None
-            validation_result = ""
-            if file_changed:
-                self._write_file_content(path, new_content)
-                # Perform syntax validation and append result
-                validation_result = validate_file_syntax(path)
-            warning, concise_warning = self._handle_warnings(
-                replaced_count, file_changed, occurrences
-            )
-
-            if concise_warning:
-                return concise_warning
-            self._report_success(match_lines)
-            line_delta_str = self._get_line_delta_str(content, new_content)
-            match_info, details = self._format_match_details(
-                replaced_count,
-                match_lines,
-                search_lines,
-                replace_lines,
-                line_delta_str,
-                replace_all,
-            )
-            return self._format_final_msg(path, warning, match_info, details) + (
-                f"\n{validation_result}" if validation_result else ""
-            )
-        except Exception as e:
-            self.report_error(tr(" ❌ Error"), ReportAction.UPDATE)
-            return tr("Error replacing text: {error}", error=e)
-
-    def _read_file_content(self, path):
-        """Read the entire content of the file."""
-        with open(path, "r", encoding="utf-8", errors="replace") as f:
-            return f.read()
-
-    def _find_match_lines(self, content, search_text):
-        """Find all line numbers where search_text occurs in content."""
-        lines = content.splitlines(keepends=True)
-        joined = "".join(lines)
-        match_lines = []
-        idx = 0
-        while True:
-            idx = joined.find(search_text, idx)
-            if idx == -1:
-                break
-            upto = joined[:idx]
-            line_no = upto.count("\n") + 1
-            match_lines.append(line_no)
-            idx += 1 if not search_text else len(search_text)
-        return match_lines
-
-    def _replace_content(
-        self, content, search_text, replacement_text, replace_all, occurrences
-    ):
-        """Replace occurrences of search_text with replacement_text in content."""
-        if replace_all:
-            replaced_count = content.count(search_text)
-            new_content = content.replace(search_text, replacement_text)
-        else:
-            if occurrences > 1:
-                return 0, content  # No changes made, not unique
-            replaced_count = 1 if occurrences == 1 else 0
-            new_content = content.replace(search_text, replacement_text, 1)
-        return replaced_count, new_content
-
-    def _backup_file(self, path, backup_path):
-        """Create a backup of the file."""
-        shutil.copy2(path, backup_path)
-
-    def _write_file_content(self, path, content):
-        """Write content to the file."""
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-
-    def _handle_warnings(self, replaced_count, file_changed, occurrences):
-        """Handle and return warnings and concise warnings if needed."""
-        warning = ""
-        concise_warning = None
-        if replaced_count == 0:
-            warning = tr(" [Warning: Search text not found in file]")
-        if not file_changed:
-            self.report_warning(
-                tr(" ℹ️  No changes made. (not found)"), ReportAction.CREATE
-            )
-            concise_warning = tr(
-                "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
-            )
-        if occurrences > 1 and replaced_count == 0:
-            self.report_warning(
-                tr(" ℹ️  No changes made. (not unique)"), ReportAction.CREATE
-            )
-            concise_warning = tr(
-                "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
-            )
-        return warning, concise_warning
-
-    def _report_success(self, match_lines):
-        """Report success with line numbers where replacements occurred."""
-        if match_lines:
-            lines_str = ", ".join(str(line_no) for line_no in match_lines)
-            self.report_success(
-                tr(" ✅ replaced at {lines_str}", lines_str=lines_str),
-                ReportAction.CREATE,
-            )
-        else:
-            self.report_success(tr(" ✅ replaced (lines unknown)"), ReportAction.CREATE)
-
-    def _get_line_delta_str(self, content, new_content):
-        """Return a string describing the net line change after replacement."""
-        total_lines_before = content.count("\n") + 1
-        total_lines_after = new_content.count("\n") + 1
-        line_delta = total_lines_after - total_lines_before
-        if line_delta > 0:
-            return f" (+{line_delta} lines)"
-        elif line_delta < 0:
-            return f" ({line_delta} lines)"
-        else:
-            return " (no net line change)"
-
-    def _format_info_msg(
-        self,
-        disp_path,
-        search_lines,
-        replace_lines,
-        action,
-        search_text,
-        replacement_text,
-        path,
-    ):
-        """Format the info message for the operation."""
-        if replace_lines == 0:
-            return tr(
-                "📝 Replace in {disp_path} del {search_lines} lines {action}",
-                disp_path=disp_path,
-                search_lines=search_lines,
-                action=action,
-            )
-        else:
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    _content = f.read()
-                _new_content = _content.replace(
-                    search_text, replacement_text, -1 if action else 1
-                )
-                _total_lines_before = _content.count("\n") + 1
-                _total_lines_after = _new_content.count("\n") + 1
-                _line_delta = _total_lines_after - _total_lines_before
-            except Exception:
-                _line_delta = replace_lines - search_lines
-            if _line_delta > 0:
-                delta_str = f"+{_line_delta} lines"
-            elif _line_delta < 0:
-                delta_str = f"{_line_delta} lines"
-            else:
-                delta_str = "+0"
-            return tr(
-                "📝 Replace in {disp_path} {delta_str} {action}",
-                disp_path=disp_path,
-                delta_str=delta_str,
-                action=action,
-            )
-
-    def _format_match_details(
-        self,
-        replaced_count,
-        match_lines,
-        search_lines,
-        replace_lines,
-        line_delta_str,
-        replace_all,
-    ):
-        """Format match info and details for the final message."""
-        if replaced_count > 0:
-            if replace_all:
-                match_info = tr(
-                    "Matches found at lines: {lines}. ",
-                    lines=", ".join(str(line) for line in match_lines),
-                )
-            else:
-                match_info = (
-                    tr("Match found at line {line}. ", line=match_lines[0])
-                    if match_lines
-                    else ""
-                )
-            details = tr(
-                "Replaced {replaced_count} occurrence(s) at above line(s): {search_lines} lines replaced with {replace_lines} lines each.{line_delta_str}",
-                replaced_count=replaced_count,
-                search_lines=search_lines,
-                replace_lines=replace_lines,
-                line_delta_str=line_delta_str,
-            )
-        else:
-            match_info = ""
-            details = ""
-        return match_info, details
-
-    def _format_final_msg(self, path, warning, match_info, details):
-        """Format the final status message."""
-        return tr(
-            "Text replaced in {path}{warning}. {match_info}{details}",
-            path=path,
-            warning=warning,
-            match_info=match_info,
-            details=details,
-        )

janito/plugins_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/__init__.py

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

janito/plugins_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/core.py

@@ -1,114 +0,0 @@
-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.tools.adapters.local.adapter import register_local_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 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)
-      - 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_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/css_validator.py

@@ -1,35 +0,0 @@
-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_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/html_validator.py

@@ -1,100 +0,0 @@
-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_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/jinja2_validator.py

@@ -1,50 +0,0 @@
-"""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_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/js_validator.py

@@ -1,27 +0,0 @@
-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_backup_20250825_070018/core/filemanager/tools/validate_file_syntax/json_validator.py

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