janito 2.33.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

janito/plugins/core/codeanalyzer/__init__.py

@@ -0,0 +1,43 @@
+"""
+Code Analyzer Plugin
+
+Tools for understanding and searching code structure.
+"""
+
+from typing import List, Optional
+
+
+def get_file_outline(path: str) -> str:
+    """Get file structure (classes, functions, etc.)"""
+    return f"get_file_outline(path='{path}')"
+
+
+get_file_outline.tool_name = "get_file_outline"
+
+
+def search_outline(path: str) -> str:
+    """Search within file outlines"""
+    return f"search_outline(path='{path}')"
+
+
+search_outline.tool_name = "search_outline"
+
+
+def search_text(
+    paths: str,
+    query: str,
+    use_regex: bool = False,
+    case_sensitive: bool = True,
+    max_depth: Optional[int] = None,
+) -> str:
+    """Full-text search across files with regex support"""
+    return f"search_text(paths='{paths}', query='{query}', regex={use_regex})"
+
+
+search_text.tool_name = "search_text"
+
+
+# Plugin metadata
+__plugin_name__ = "core.codeanalyzer"
+__plugin_description__ = "Code analysis and structure understanding"
+__plugin_tools__ = [get_file_outline, search_outline, search_text]

janito/plugins/core/filemanager/__init__.py

@@ -0,0 +1,124 @@
+"""
+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/create_file.py

@@ -0,0 +1,87 @@
+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.
+    Maximum 5 calls per 10 seconds for the same file path.
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "create_file"
+
+    @protect_against_loops(max_calls=5, 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/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/core/imagedisplay/__init__.py

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

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

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

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

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