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

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

@@ -0,0 +1,131 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class MoveFileTool(ToolBase):
+    """
+    Move a file or directory from src_path to dest_path.
+
+    Args:
+        src_path (str): Source file or directory path.
+        dest_path (str): Destination file or directory path.
+        overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    permissions = ToolPermissions(read=True, write=True)
+    tool_name = "move_file"
+
+    def run(
+        self,
+        src_path: str,
+        dest_path: str,
+        overwrite: bool = False,
+        backup: bool = False,
+    ) -> str:
+        src = expand_path(src_path)
+        dest = expand_path(dest_path)
+        original_src = src_path
+        original_dest = dest_path
+        disp_src = display_path(original_src)
+        disp_dest = display_path(original_dest)
+        backup_path = None
+
+        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
+        if not valid:
+            return err_msg
+
+        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
+        if dest_result is not None:
+            backup_path, err_msg = dest_result
+            if err_msg:
+                return err_msg
+
+        try:
+            self.report_action(
+                tr(
+                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
+                    disp_src=disp_src,
+                    disp_dest=disp_dest,
+                ),
+                ReportAction.UPDATE,
+            )
+            shutil.move(src, dest)
+            self.report_success(tr("✅ Move complete."))
+            msg = tr("✅ Move complete.")
+
+            return msg
+        except Exception as e:
+            self.report_error(tr("❌ Error moving: {error}", error=e))
+            return tr("❌ Error moving: {error}", error=e)
+
+    def _validate_source(self, src, disp_src):
+        if not os.path.exists(src):
+            self.report_error(
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+            )
+            return (
+                False,
+                False,
+                False,
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
+            )
+        is_src_file = os.path.isfile(src)
+        is_src_dir = os.path.isdir(src)
+        if not (is_src_file or is_src_dir):
+            self.report_error(
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                )
+            )
+            return (
+                False,
+                False,
+                False,
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                ),
+            )
+        return True, is_src_file, is_src_dir, None
+
+    def _handle_destination(self, dest, disp_dest, overwrite, backup):
+        backup_path = None
+        if os.path.exists(dest):
+            if not overwrite:
+                self.report_error(
+                    tr(
+                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
+                        disp_dest=disp_dest,
+                    ),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
+                    disp_dest=disp_dest,
+                )
+
+            try:
+                if os.path.isfile(dest):
+                    os.remove(dest)
+                elif os.path.isdir(dest):
+                    shutil.rmtree(dest)
+            except Exception as e:
+                self.report_error(
+                    tr("❌ Error removing destination before move: {error}", error=e),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❌ Error removing destination before move: {error}", error=e
+                )
+        return backup_path, None

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

@@ -0,0 +1,58 @@
+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 pluralize
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ReadFilesTool(ToolBase):
+    """
+    Read all text content from multiple files.
+
+    Args:
+        paths (list[str]): List of file paths to read.
+
+    Returns:
+        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "read_files"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(self, paths: list[str]) -> str:
+        from janito.tools.tool_utils import display_path
+        import os
+        from janito.tools.path_utils import expand_path
+
+        results = []
+        for path in [expand_path(p) for p in paths]:
+            disp_path = display_path(path)
+            self.report_action(
+                tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ
+            )
+            if not os.path.isfile(path):
+                self.report_warning(
+                    tr("❗ not found: {disp_path}", disp_path=disp_path)
+                )
+                results.append(f"--- File: {disp_path} (not found) ---\n")
+                continue
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read()
+                results.append(f"--- File: {disp_path} ---\n{content}\n")
+                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
+            except Exception as e:
+                self.report_error(
+                    tr(
+                        " ❌ Error reading {disp_path}: {error}",
+                        disp_path=disp_path,
+                        error=e,
+                    )
+                )
+                results.append(
+                    f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
+                )
+        return "\n".join(results)

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

@@ -0,0 +1,55 @@
+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 pluralize, display_path
+from janito.i18n import tr
+import shutil
+import os
+import zipfile
+from janito.tools.path_utils import expand_path
+
+
+@register_local_tool
+class RemoveDirectoryTool(ToolBase):
+    """
+    Remove a directory.
+
+    Args:
+        path (str): Path to the directory to remove.
+        recursive (bool, optional): If True, remove non-empty directories recursively (with backup). If False, only remove empty directories. Defaults to False.
+    Returns:
+        str: Status message indicating result. Example:
+            - "Directory removed: /path/to/dir"
+            - "Error removing directory: <error message>"
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "remove_directory"
+
+    def run(self, path: str, recursive: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.DELETE,
+        )
+
+        try:
+            if recursive:
+
+                shutil.rmtree(path)
+            else:
+                os.rmdir(path)
+            self.report_success(
+                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
+                ReportAction.DELETE,
+            )
+            msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
+
+            return msg
+        except Exception as e:
+            self.report_error(
+                tr(" ❌ Error removing directory: {error}", error=e),
+                ReportAction.DELETE,
+            )
+            return tr("Error removing directory: {error}", error=e)

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

@@ -0,0 +1,58 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from janito.tools.adapters.local.adapter import register_local_tool
+
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class RemoveFileTool(ToolBase):
+    """
+    Remove a file at the specified path.
+
+    Args:
+        path (str): Path to the file to remove.
+        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "			 Successfully removed the file at ..."
+            - "			 Cannot remove file: ..."
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "remove_file"
+
+    def run(self, path: str, backup: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+
+        # Report initial info about what is going to be removed
+        self.report_action(
+            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.DELETE,
+        )
+        if not os.path.exists(path):
+            self.report_error(tr("❌ File does not exist."), ReportAction.DELETE)
+            return tr("❌ File does not exist.")
+        if not os.path.isfile(path):
+            self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
+            return tr("❌ Path is not a file.")
+        try:
+
+            os.remove(path)
+            self.report_success(tr("✅ File removed"), ReportAction.DELETE)
+            msg = tr(
+                "✅ Successfully removed the file at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+
+            return msg
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error removing file: {error}", error=e), ReportAction.DELETE
+            )
+            return tr("❌ Error removing file: {error}", error=e)

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

@@ -0,0 +1,270 @@
+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

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

janito/plugins_backup_20250825_070018/core/filemanager/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.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