janito 3.6.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

janito/plugins/core/filemanager/__init__.py

@@ -1,124 +0,0 @@
-"""
-File Manager Plugin
-
-Core file and directory operations for managing project files.
-"""
-
-from typing import List, Optional
-import os
-
-
-def create_file(path: str, content: str = "", overwrite: bool = False) -> str:
-    """Create a new file with content"""
-    return f"create_file(path='{path}', content='{len(content)} chars', overwrite={overwrite})"
-
-
-create_file.tool_name = "create_file"
-
-
-def read_files(paths: List[str]) -> str:
-    """Read multiple files at once"""
-    return f"read_files(paths={paths})"
-
-
-read_files.tool_name = "read_files"
-
-
-def view_file(
-    path: str, from_line: Optional[int] = None, to_line: Optional[int] = None
-) -> str:
-    """Read specific lines or entire files"""
-    range_str = f"{from_line}-{to_line}" if from_line or to_line else "all"
-    return f"view_file(path='{path}', range='{range_str}')"
-
-
-view_file.tool_name = "view_file"
-
-
-def replace_text_in_file(
-    path: str, search_text: str, replacement_text: str, replace_all: bool = True
-) -> str:
-    """Find and replace text in files"""
-    return f"replace_text_in_file(path='{path}', search='{search_text[:20]}...', replace='{replacement_text[:20]}...')"
-
-
-replace_text_in_file.tool_name = "replace_text_in_file"
-
-
-def validate_file_syntax(path: str) -> str:
-    """Check file syntax (Python/Markdown)"""
-    return f"validate_file_syntax(path='{path}')"
-
-
-validate_file_syntax.tool_name = "validate_file_syntax"
-
-
-def create_directory(path: str) -> str:
-    """Create new directories"""
-    return f"create_directory(path='{path}')"
-
-
-create_directory.tool_name = "create_directory"
-
-
-def remove_directory(path: str, recursive: bool = False) -> str:
-    """Remove directories (recursive option)"""
-    return f"remove_directory(path='{path}', recursive={recursive})"
-
-
-remove_directory.tool_name = "remove_directory"
-
-
-def remove_file(path: str) -> str:
-    """Delete single files"""
-    return f"remove_file(path='{path}')"
-
-
-remove_file.tool_name = "remove_file"
-
-
-def copy_file(sources: str, target: str, overwrite: bool = False) -> str:
-    """Copy files or directories"""
-    return f"copy_file(sources='{sources}', target='{target}', overwrite={overwrite})"
-
-
-copy_file.tool_name = "copy_file"
-
-
-def move_file(src_path: str, dest_path: str, overwrite: bool = False) -> str:
-    """Move/rename files or directories"""
-    return f"move_file(src='{src_path}', dest='{dest_path}', overwrite={overwrite})"
-
-
-move_file.tool_name = "move_file"
-
-
-def find_files(
-    paths: str,
-    pattern: str,
-    max_depth: Optional[int] = None,
-    include_gitignored: bool = False,
-) -> str:
-    """Search for files by pattern (respects .gitignore)"""
-    return f"find_files(paths='{paths}', pattern='{pattern}', max_depth={max_depth})"
-
-
-find_files.tool_name = "find_files"
-
-
-# Plugin metadata
-__plugin_name__ = "core.filemanager"
-__plugin_description__ = "Core file and directory operations"
-__plugin_tools__ = [
-    create_file,
-    read_files,
-    view_file,
-    replace_text_in_file,
-    validate_file_syntax,
-    create_directory,
-    remove_directory,
-    remove_file,
-    copy_file,
-    move_file,
-    find_files,
-]

janito/plugins/core/filemanager/tools/copy_file.py

@@ -1,87 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-import shutil
-from typing import List, Union
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.tool_utils import display_path
-from janito.report_events import ReportAction
-from janito.i18n import tr
-
-
-@register_local_tool
-class CopyFileTool(ToolBase):
-    """
-    Copy one or more files to a target directory, or copy a single file to a new file.
-    Args:
-        sources (str): Space-separated path(s) to the file(s) to copy.
-            For multiple sources, provide a single string with paths separated by spaces.
-        target (str): Destination path. If copying multiple sources, this must be an existing directory.
-        overwrite (bool, optional): Overwrite existing files. Default: False.
-            Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status string for each copy operation.
-    """
-
-    permissions = ToolPermissions(read=True, write=True)
-    tool_name = "copy_file"
-
-    def run(self, sources: str, target: str, overwrite: bool = False) -> str:
-        source_list = [expand_path(src) for src in sources.split() if src]
-        target = expand_path(target)
-        messages = []
-        if len(source_list) > 1:
-            if not os.path.isdir(target):
-                return tr(
-                    "❗ Target must be an existing directory when copying multiple files: '{target}'",
-                    target=display_path(target),
-                )
-            for src in source_list:
-                if not os.path.isfile(src):
-                    messages.append(
-                        tr(
-                            "❗ Source file does not exist: '{src}'",
-                            src=display_path(src),
-                        )
-                    )
-                    continue
-                dst = os.path.join(target, os.path.basename(src))
-                messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        else:
-            src = source_list[0]
-            if os.path.isdir(target):
-                dst = os.path.join(target, os.path.basename(src))
-            else:
-                dst = target
-            messages.append(self._copy_one(src, dst, overwrite=overwrite))
-        return "\n".join(messages)
-
-    def _copy_one(self, src, dst, overwrite=False) -> str:
-        disp_src = display_path(src)
-        disp_dst = display_path(dst)
-        if not os.path.isfile(src):
-            return tr("❗ Source file does not exist: '{src}'", src=disp_src)
-        if os.path.exists(dst) and not overwrite:
-            return tr(
-                "❗ Target already exists: '{dst}'. Set overwrite=True to replace.",
-                dst=disp_dst,
-            )
-        try:
-            os.makedirs(os.path.dirname(dst), exist_ok=True)
-            shutil.copy2(src, dst)
-            note = (
-                "\n⚠️ Overwrote existing file. (recommended only after reading the file to be overwritten)"
-                if (os.path.exists(dst) and overwrite)
-                else ""
-            )
-            self.report_success(
-                tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst)
-            )
-            return tr("✅ Copied '{src}' to '{dst}'", src=disp_src, dst=disp_dst) + note
-        except Exception as e:
-            return tr(
-                "❗ Copy failed from '{src}' to '{dst}': {err}",
-                src=disp_src,
-                dst=disp_dst,
-                err=str(e),
-            )

janito/plugins/core/filemanager/tools/create_file.py

@@ -1,87 +0,0 @@
-import os
-from janito.tools.path_utils import expand_path
-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
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
-
-
-@register_local_tool
-class CreateFileTool(ToolBase):
-    """
-    Create a new file with the given content.
-
-    Args:
-        path (str): Path to the file to create.
-        content (str): Content to write to the file.
-        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully created the file at ..."
-
-    Note: Syntax validation is automatically performed after this operation.
-
-    Security: This tool includes loop protection to prevent excessive file creation operations.
-    Protection: Prevents repeated create calls for the same file path within a short window (1 allowed per 10 seconds).
-    """
-
-    permissions = ToolPermissions(write=True)
-    tool_name = "create_file"
-
-    @protect_against_loops(max_calls=1, time_window=10.0, key_field="path")
-    def run(self, path: str, content: str, overwrite: bool = False) -> str:
-        path = expand_path(path)
-        disp_path = display_path(path)
-        if os.path.exists(path) and not overwrite:
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    existing_content = f.read()
-            except Exception as e:
-                existing_content = f"[Error reading file: {e}]"
-            return tr(
-                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
-                disp_path=disp_path,
-                existing_content=existing_content,
-            )
-        # Determine if we are overwriting an existing file
-        is_overwrite = os.path.exists(path) and overwrite
-        if is_overwrite:
-            # Overwrite branch: log only overwrite warning (no create message)
-            self.report_action(
-                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        dir_name = os.path.dirname(path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        if not is_overwrite:
-            # Create branch: log file creation message
-            self.report_action(
-                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
-                ReportAction.CREATE,
-            )
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-        new_lines = content.count("\n") + 1 if content else 0
-        self.report_success(
-            tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
-        )
-        # Perform syntax validation and append result
-        validation_result = validate_file_syntax(path)
-        if is_overwrite:
-            # Overwrite branch: return minimal overwrite info to user
-            return (
-                tr("✅ {new_lines} lines", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )
-        else:
-            # Create branch: return detailed create success to user
-            return (
-                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
-                + f"\n{validation_result}"
-            )

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

@@ -1,131 +0,0 @@
-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/core/filemanager/tools/remove_file.py

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