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

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

@@ -1,109 +0,0 @@
-from janito.i18n import tr
-import re
-
-
-def validate_markdown(path: str) -> str:
-    with open(path, "r", encoding="utf-8") as f:
-        content = f.read()
-    lines = content.splitlines()
-    errors = []
-    errors.extend(_check_header_space(lines))
-    errors.extend(_check_unclosed_code_block(content))
-    errors.extend(_check_unclosed_links_images(lines))
-    errors.extend(_check_list_formatting(lines))
-    errors.extend(_check_unclosed_inline_code(content))
-    return _build_markdown_result(errors)
-
-
-def _check_header_space(lines):
-    errors = []
-    for i, line in enumerate(lines, 1):
-        if re.match(r"^#+[^ #]", line):
-            errors.append(f"Line {i}: Header missing space after # | {line.strip()}")
-    return errors
-
-
-def _check_unclosed_code_block(content):
-    errors = []
-    if content.count("```") % 2 != 0:
-        errors.append("Unclosed code block (```) detected")
-    return errors
-
-
-def _check_unclosed_links_images(lines):
-    errors = []
-    for i, line in enumerate(lines, 1):
-        if re.search(r"\[[^\]]*\]\([^)]+$", line):
-            errors.append(
-                f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
-            )
-    return errors
-
-
-def _is_table_line(line):
-    return line.lstrip().startswith("|")
-
-
-def _list_item_missing_space(line):
-    return re.match(r"^[-*+][^ \n]", line)
-
-
-def _should_skip_list_item(line):
-    stripped = line.strip()
-    return stripped.startswith("*") and stripped.endswith("*") and len(stripped) > 2
-
-
-def _needs_blank_line_before_bullet(lines, i):
-    if i <= 1:
-        return False
-    prev_line = lines[i - 2]
-    prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
-    return not prev_is_list and prev_line.strip() != ""
-
-
-def _needs_blank_line_before_numbered(lines, i):
-    if i <= 1:
-        return False
-    prev_line = lines[i - 2]
-    prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
-    return not prev_is_numbered_list and prev_line.strip() != ""
-
-
-def _check_list_formatting(lines):
-    errors = []
-    for i, line in enumerate(lines, 1):
-        if _is_table_line(line):
-            continue
-        if _list_item_missing_space(line):
-            if not _should_skip_list_item(line):
-                errors.append(
-                    f"Line {i}: List item missing space after bullet | {line.strip()}"
-                )
-        if re.match(r"^\s*[-*+] ", line):
-            if _needs_blank_line_before_bullet(lines, i):
-                errors.append(
-                    f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
-                )
-        if re.match(r"^\s*\d+\. ", line):
-            if _needs_blank_line_before_numbered(lines, i):
-                errors.append(
-                    f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
-                )
-    return errors
-
-
-def _check_unclosed_inline_code(content):
-    errors = []
-    if content.count("`") % 2 != 0:
-        errors.append("Unclosed inline code (`) detected")
-    return errors
-
-
-def _build_markdown_result(errors):
-    if errors:
-        msg = tr(
-            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
-            errors="\n".join(errors),
-        )
-        return msg
-    return "✅ OK"

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

@@ -1,32 +0,0 @@
-from janito.i18n import tr
-import re
-
-
-def validate_ps1(path: str) -> str:
-    with open(path, "r", encoding="utf-8") as f:
-        content = f.read()
-    errors = []
-    # Unmatched curly braces
-    if content.count("{") != content.count("}"):
-        errors.append("Unmatched curly braces { }")
-    # Unmatched parentheses
-    if content.count("(") != content.count(")"):
-        errors.append("Unmatched parentheses ( )")
-    # Unmatched brackets
-    if content.count("[") != content.count("]"):
-        errors.append("Unmatched brackets [ ]")
-    # Unclosed string literals
-    for quote in ["'", '"']:
-        unescaped = re.findall(rf"(?<!\\){quote}", content)
-        if len(unescaped) % 2 != 0:
-            errors.append(f"Unclosed string literal ({quote}) detected")
-    # Unclosed block comments <# ... #>
-    if content.count("<#") != content.count("#>"):
-        errors.append("Unclosed block comment (<# ... #>)")
-    if errors:
-        msg = tr(
-            "⚠️ Warning: PowerShell syntax issues found:\n{errors}",
-            errors="\n".join(errors),
-        )
-        return msg
-    return "✅ OK"

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

@@ -1,5 +0,0 @@
-def validate_python(path: str) -> str:
-    import py_compile
-
-    py_compile.compile(path, doraise=True)
-    return "✅ OK"

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

@@ -1,11 +0,0 @@
-from janito.i18n import tr
-
-
-def validate_xml(path: str) -> str:
-    try:
-        from lxml import etree
-    except ImportError:
-        return tr("⚠️ lxml not installed. Cannot validate XML.")
-    with open(path, "rb") as f:
-        etree.parse(f)
-    return "✅ OK"

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

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

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

@@ -1,172 +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.tools.tool_utils import pluralize
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-class ViewFileTool(ToolBase):
-    """
-    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
-
-    Args:
-        path (str): Path to the file to read lines from.
-        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
-        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
-
-    To read the full file, just provide path and leave from_line and to_line unset.
-
-    Returns:
-        str: File content with a header indicating the file name and line range. Example:
-            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
-            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
-            - "Error reading file: <error message>"
-            - "❗ not found"
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "view_file"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
-        import os
-        from janito.tools.tool_utils import display_path
-        from janito.tools.path_utils import expand_path
-
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("📖 View '{disp_path}'", disp_path=disp_path),
-            ReportAction.READ,
-        )
-        try:
-            if os.path.isdir(path):
-                return self._list_directory(path, disp_path)
-            lines = self._read_file_lines(path)
-            selected, selected_len, total_lines = self._select_lines(
-                lines, from_line, to_line
-            )
-            self._report_success(selected_len, from_line, to_line, total_lines)
-            header = self._format_header(
-                disp_path, from_line, to_line, selected_len, total_lines
-            )
-            return header + "".join(selected)
-        except FileNotFoundError as e:
-            self.report_warning(tr("❗ not found"))
-            return f"Error reading file: {e}"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)
-
-    def _list_directory(self, path, disp_path):
-        import os
-
-        try:
-            entries = os.listdir(path)
-            entries.sort()
-            # Suffix subdirectories with '/'
-            formatted_entries = []
-            for entry in entries:
-                full_path = os.path.join(path, entry)
-                if os.path.isdir(full_path):
-                    formatted_entries.append(entry + "/")
-                else:
-                    formatted_entries.append(entry)
-            header = (
-                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
-            )
-            listing = "\n".join(formatted_entries)
-            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
-            return header + listing + "\n"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
-            return tr("Error listing directory: {error}", error=e)
-
-    def _read_file_lines(self, path):
-        """Read all lines from the file."""
-        with open(path, "r", encoding="utf-8", errors="replace") as f:
-            return f.readlines()
-
-    def _select_lines(self, lines, from_line, to_line):
-        """Select the requested lines and return them with their count and total lines."""
-        selected = lines[
-            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
-        ]
-        selected_len = len(selected)
-        total_lines = len(lines)
-        return selected, selected_len, total_lines
-
-    def _report_success(self, selected_len, from_line, to_line, total_lines):
-        """Report the success message after reading lines."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = to_line >= total_lines or selected_len < requested
-            if at_end:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} (end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                    )
-                )
-            elif to_line < total_lines:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} ({remaining} to end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                        remaining=total_lines - to_line,
-                    )
-                )
-        else:
-            self.report_success(
-                tr(
-                    " ✅ {selected_len} {line_word} (all)",
-                    selected_len=selected_len,
-                    line_word=pluralize("line", selected_len),
-                )
-            )
-
-    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
-        """Format the header for the output."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = selected_len < requested or to_line >= total_lines
-            if at_end:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                )
-            else:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                    total_lines=total_lines,
-                )
-        elif from_line:
-            return tr(
-                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
-                disp_path=disp_path,
-                from_line=from_line,
-                total_lines=total_lines,
-            )
-        else:
-            return tr(
-                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
-                disp_path=disp_path,
-                total_lines=total_lines,
-            )
-
-    def _handle_read_error(self, e):
-        """Handle file read errors and report appropriately."""
-        if isinstance(e, FileNotFoundError):
-            self.report_error(tr("❗ not found"), ReportAction.READ)
-            return tr("❗ not found")
-        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
-        return tr("Error reading file: {error}", error=e)

janito/plugins_backup_20250825_070018/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_backup_20250825_070018/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_backup_20250825_070018/core/imagedisplay/tools/__init__.py

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

janito/plugins_backup_20250825_070018/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_backup_20250825_070018/core/imagedisplay/tools/show_image_grid.py

@@ -1,84 +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
-from typing import Sequence
-
-
-class ShowImageGridTool(ToolBase):
-    """Display multiple images in a grid inline in the terminal using rich.
-
-    Args:
-        paths (list[str]): List of image file paths.
-        columns (int, optional): Number of columns in the grid. Default: 2.
-        width (int, optional): Max width for each image cell. Default: None (auto).
-        height (int, optional): Max height for each image cell. Default: None (auto).
-        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
-
-    Returns:
-        str: Status string summarizing the grid display.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "show_image_grid"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(
-        self,
-        paths: Sequence[str],
-        columns: int = 2,
-        width: int | None = None,
-        height: int | None = None,
-        preserve_aspect: bool = True,
-    ) -> str:
-        from janito.tools.path_utils import expand_path
-        from janito.tools.tool_utils import display_path
-        import os
-
-        try:
-            from rich.console import Console
-            from rich.columns import Columns
-            from PIL import Image as PILImage
-            from rich.panel import Panel
-        except Exception as e:
-            msg = tr("⚠️ Missing dependency: PIL/Pillow ({error})", error=e)
-            self.report_error(msg)
-            return msg
-
-        if not paths:
-            return tr("No images provided")
-
-        self.report_action(
-            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
-        )
-
-        console = Console()
-        images = []
-        shown = 0
-        for p in paths:
-            fp = expand_path(p)
-            if not os.path.exists(fp):
-                self.report_warning(tr("❗ not found: {p}", p=display_path(fp)))
-                continue
-            try:
-                img = PILImage.open(fp)
-                title = f"{display_path(fp)} ({img.width}x{img.height})"
-                images.append(
-                    Panel.fit(title, title=display_path(fp), border_style="dim")
-                )
-                shown += 1
-            except Exception as e:
-                self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
-
-        if not images:
-            return tr("No images could be displayed")
-
-        # Render in columns (grid-like)
-        console.print(Columns(images, equal=True, expand=True, columns=columns))
-        self.report_success(tr("✅ Displayed {n} images", n=shown))
-        return tr(
-            "Displayed {shown}/{total} images in a {cols}x? grid",
-            shown=shown,
-            total=len(paths),
-            cols=columns,
-        )

janito/plugins_backup_20250825_070018/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]