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

janito/plugins/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/core/imagedisplay/__init__.py

@@ -1,14 +0,0 @@
-"""
-Image Display Plugin - Core plugin for displaying images inline in the terminal.
-
-This plugin provides tools for displaying images directly in the terminal using
-rich library's image rendering capabilities.
-"""
-
-from .plugin import ImageDisplayPlugin
-
-# Plugin metadata for discovery/listing
-__plugin_name__ = "core.imagedisplay"
-__plugin_description__ = "Display images inline in the terminal using rich"
-
-__all__ = ["ImageDisplayPlugin"]

janito/plugins/core/imagedisplay/plugin.py

@@ -1,51 +0,0 @@
-"""
-Image Display Plugin implementation.
-"""
-
-from typing import Dict, Any, List, Type
-
-from janito.plugin_system.base import Plugin, PluginMetadata
-from janito.tools.tool_base import ToolBase
-from .tools.show_image import ShowImageTool
-from .tools.show_image_grid import ShowImageGridTool
-
-
-class ImageDisplayPlugin(Plugin):
-    """Plugin for displaying images inline in the terminal using rich."""
-
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name="core.imagedisplay",
-            version="1.0.0",
-            description="Display images inline in the terminal using rich",
-            author="Janito",
-            dependencies=["rich", "pillow"],
-        )
-
-    def get_tools(self) -> List[Type[ToolBase]]:
-        # Return tool classes so the PluginManager can register them
-        return [ShowImageTool, ShowImageGridTool]
-
-    def get_config_schema(self) -> Dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "default_width": {
-                    "type": "integer",
-                    "description": "Default width for image display",
-                    "minimum": 1,
-                    "maximum": 200,
-                },
-                "default_height": {
-                    "type": "integer",
-                    "description": "Default height for image display",
-                    "minimum": 1,
-                    "maximum": 100,
-                },
-                "preserve_aspect": {
-                    "type": "boolean",
-                    "description": "Preserve aspect ratio by default",
-                    "default": True,
-                },
-            },
-        }

janito/plugins/core/imagedisplay/tools/__init__.py

@@ -1 +0,0 @@
-"""Tools for image display plugin."""

janito/plugins/core/imagedisplay/tools/show_image.py

@@ -1,83 +0,0 @@
-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
-
-
-class ShowImageTool(ToolBase):
-    """Display an image inline in the terminal using the rich library.
-
-    Args:
-        path (str): Path to the image file.
-        width (int, optional): Target width in terminal cells. If unset, auto-fit.
-        height (int, optional): Target height in terminal rows. If unset, auto-fit.
-        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
-
-    Returns:
-        str: Status message indicating display result or error details.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "show_image"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(
-        self,
-        path: str,
-        width: int | None = None,
-        height: int | None = None,
-        preserve_aspect: bool = True,
-    ) -> str:
-        from janito.tools.tool_utils import display_path
-        from janito.tools.path_utils import expand_path
-        import os
-
-        # Defer heavy imports to runtime
-        try:
-            from rich.console import Console
-            from PIL import Image as PILImage
-        except Exception as e:
-            msg = tr("⚠️ Missing dependency: PIL/Pillow ({error})", error=e)
-            self.report_error(msg)
-            return msg
-
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ
-        )
-
-        if not os.path.exists(path):
-            msg = tr("❗ not found")
-            self.report_warning(msg)
-            return tr("Error: file not found: {path}", path=disp_path)
-
-        try:
-            console = Console()
-            # rich.image.Image handles inline terminal display of common formats
-            from rich.console import Console
-            from rich.text import Text
-
-            console = Console()
-            img = PILImage.open(path)
-            console.print(
-                Text(
-                    f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"
-                )
-            )
-            console.print(img)
-            self.report_success(tr("✅ Displayed"))
-            details = []
-            if width:
-                details.append(f"width={width}")
-            if height:
-                details.append(f"height={height}")
-            if not preserve_aspect:
-                details.append("preserve_aspect=False")
-            info = ("; ".join(details)) if details else "auto-fit"
-            return tr(
-                "Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info
-            )
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error displaying image: {error}", error=e)

janito/plugins/core/system/__init__.py

@@ -1,23 +0,0 @@
-"""
-System Tools Plugin
-
-System-level operations and shell access.
-"""
-
-from typing import Optional
-
-
-def run_powershell_command(
-    command: str, timeout: int = 60, require_confirmation: bool = False
-) -> str:
-    """Execute PowerShell commands"""
-    return f"run_powershell_command(command='{command[:50]}...', timeout={timeout})"
-
-
-run_powershell_command.tool_name = "run_powershell_command"
-
-
-# Plugin metadata
-__plugin_name__ = "core.system"
-__plugin_description__ = "System-level operations and shell access"
-__plugin_tools__ = [run_powershell_command]

janito/plugins/dev/__init__.py

@@ -1,7 +0,0 @@
-"""
-Development Plugin Package
-
-Contains development-specific tools and utilities.
-"""
-
-__all__ = ["pythondev", "visualization"]

janito/plugins/dev/pythondev/__init__.py

@@ -1,37 +0,0 @@
-"""
-Python Development Plugin
-
-Python development and execution tools.
-"""
-
-from typing import Optional
-
-
-def python_code_run(code: str, timeout: int = 60) -> str:
-    """Execute Python code via stdin"""
-    return f"python_code_run(code='{len(code)} chars', timeout={timeout})"
-
-
-python_code_run.tool_name = "python_code_run"
-
-
-def python_command_run(code: str, timeout: int = 60) -> str:
-    """Execute Python with -c flag"""
-    return f"python_command_run(code='{len(code)} chars', timeout={timeout})"
-
-
-python_command_run.tool_name = "python_command_run"
-
-
-def python_file_run(path: str, timeout: int = 60) -> str:
-    """Run Python script files"""
-    return f"python_file_run(path='{path}', timeout={timeout})"
-
-
-python_file_run.tool_name = "python_file_run"
-
-
-# Plugin metadata
-__plugin_name__ = "dev.pythondev"
-__plugin_description__ = "Python development and execution"
-__plugin_tools__ = [python_code_run, python_command_run, python_file_run]

janito/plugins/dev/visualization/__init__.py

@@ -1,23 +0,0 @@
-"""
-Visualization Plugin
-
-Data visualization and charting tools.
-"""
-
-from typing import Dict, Any
-
-
-def read_chart(
-    data: Dict[str, Any], title: str = "Chart", width: int = 80, height: int = 20
-) -> str:
-    """Display charts in terminal (bar, line, pie, table)"""
-    return f"read_chart(type='{data.get('type')}', title='{title}')"
-
-
-read_chart.tool_name = "read_chart"
-
-
-# Plugin metadata
-__plugin_name__ = "dev.visualization"
-__plugin_description__ = "Data visualization and charts"
-__plugin_tools__ = [read_chart]

janito/plugins/example_plugin.py

@@ -1,108 +0,0 @@
-"""
-Example plugin demonstrating the plugin system.
-"""
-
-from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from typing import Dict, Any
-
-
-class HelloWorldTool(ToolBase):
-    """A simple tool that says hello."""
-
-    tool_name = "hello_world"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, name: str = "World") -> str:
-        """
-        Say hello to someone.
-
-        Args:
-            name: Name of the person to greet
-
-        Returns:
-            Greeting message
-        """
-        self.report_action(f"Saying hello to {name}", "greet")
-        return f"Hello, {name}!"
-
-
-class CalculatorTool(ToolBase):
-    """A simple calculator tool."""
-
-    tool_name = "calculator"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-
-    def run(self, operation: str, a: float, b: float) -> str:
-        """
-        Perform basic calculations.
-
-        Args:
-            operation: Operation to perform (add, subtract, multiply, divide)
-            a: First number
-            b: Second number
-
-        Returns:
-            Result as string
-        """
-        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
-
-        if operation == "add":
-            result = a + b
-        elif operation == "subtract":
-            result = a - b
-        elif operation == "multiply":
-            result = a * b
-        elif operation == "divide":
-            if b == 0:
-                return "Error: Division by zero"
-            result = a / b
-        else:
-            return f"Error: Unknown operation '{operation}'"
-
-        return str(result)
-
-
-class ExamplePlugin(Plugin):
-    """Example plugin providing basic tools."""
-
-    def get_metadata(self) -> PluginMetadata:
-        return PluginMetadata(
-            name="example",
-            version="1.0.0",
-            description="Example plugin with basic tools",
-            author="Janito Team",
-            license="MIT",
-            homepage="https://github.com/janito/example-plugin",
-        )
-
-    def get_tools(self):
-        return [HelloWorldTool, CalculatorTool]
-
-    def initialize(self):
-        print("Example plugin initialized!")
-
-    def cleanup(self):
-        print("Example plugin cleaned up!")
-
-    def get_config_schema(self) -> Dict[str, Any]:
-        """Return JSON schema for plugin configuration."""
-        return {
-            "type": "object",
-            "properties": {
-                "greeting_prefix": {
-                    "type": "string",
-                    "description": "Custom greeting prefix for hello_world tool",
-                    "default": "Hello",
-                },
-                "max_calculation": {
-                    "type": "number",
-                    "description": "Maximum allowed calculation result",
-                    "default": 1000000,
-                },
-            },
-        }
-
-
-# This makes the plugin discoverable
-PLUGIN_CLASS = ExamplePlugin

janito/plugins/tools/__init__.py

@@ -1,10 +0,0 @@
-"""
-Core tools plugin for janito.
-
-This plugin provides the essential tools for file operations, code execution,
-and system interactions that are core to janito's functionality.
-"""
-
-from .core_tools_plugin import CoreToolsPlugin
-
-__all__ = ["CoreToolsPlugin"]