janito 3.12.1__py3-none-any.whl → 3.12.2__py3-none-any.whl

janito/plugins/builtin.py

@@ -1,88 +1,64 @@
-"""
-Builtin plugin system for janito-packaged plugins.
-
-This module provides the infrastructure for plugins that are bundled
-with janito and available by default without requiring external installation.
-"""
-
-import importlib
-from typing import Dict, List, Optional, Type
-from janito.plugins.base import Plugin
-
-
-class BuiltinPluginRegistry:
-    """Registry for builtin plugins that come packaged with janito."""
-
-    _plugins: Dict[str, Type[Plugin]] = {}
-
-    @classmethod
-    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
-        """Register a builtin plugin."""
-        cls._plugins[name] = plugin_class
-
-    @classmethod
-    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
-        """Get the plugin class for a builtin plugin."""
-        return cls._plugins.get(name)
-
-    @classmethod
-    def list_builtin_plugins(cls) -> List[str]:
-        """List all registered builtin plugins."""
-        return list(cls._plugins.keys())
-
-    @classmethod
-    def is_builtin(cls, name: str) -> bool:
-        """Check if a plugin is builtin."""
-        return name in cls._plugins
-
-
-def register_builtin_plugin(name: str):
-    """Decorator to register a plugin as builtin."""
-
-    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
-        BuiltinPluginRegistry.register(name, plugin_class)
-        return plugin_class
-
-    return decorator
-
-
-def load_builtin_plugin(name: str) -> Optional[Plugin]:
-    """Load a builtin plugin by name."""
-    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
-    if plugin_class:
-        return plugin_class()
-    return None
-
-
-# Auto-register janito-coder plugins as builtin
-try:
-    from janito_coder.plugins import (
-        GitAnalyzerPlugin,
-        CodeNavigatorPlugin,
-        DependencyAnalyzerPlugin,
-        CodeFormatterPlugin,
-        TestRunnerPlugin,
-        LinterPlugin,
-        DebuggerPlugin,
-        PerformanceProfilerPlugin,
-        SecurityScannerPlugin,
-        DocumentationGeneratorPlugin,
-    )
-
-    # Register all janito-coder plugins as builtin
-    BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
-    BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
-    BuiltinPluginRegistry.register("dependency_analyzer", DependencyAnalyzerPlugin)
-    BuiltinPluginRegistry.register("code_formatter", CodeFormatterPlugin)
-    BuiltinPluginRegistry.register("test_runner", TestRunnerPlugin)
-    BuiltinPluginRegistry.register("linter", LinterPlugin)
-    BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
-    BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
-    BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
-    BuiltinPluginRegistry.register(
-        "documentation_generator", DocumentationGeneratorPlugin
-    )
-
-except ImportError:
-    # janito-coder not available, skip registration
-    pass
+"""
+Builtin plugin system for janito-packaged plugins.
+
+This module provides the infrastructure for plugins that are bundled
+with janito and available by default without requiring external installation.
+"""
+
+import importlib
+from typing import Dict, List, Optional, Type
+from janito.plugins.base import Plugin
+
+
+class BuiltinPluginRegistry:
+    """Registry for builtin plugins that come packaged with janito."""
+
+    _plugins: Dict[str, Type[Plugin]] = {}
+
+    @classmethod
+    def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
+        """Register a builtin plugin."""
+        cls._plugins[name] = plugin_class
+
+    @classmethod
+    def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
+        """Get the plugin class for a builtin plugin."""
+        return cls._plugins.get(name)
+
+    @classmethod
+    def list_builtin_plugins(cls) -> List[str]:
+        """List all registered builtin plugins."""
+        return list(cls._plugins.keys())
+
+    @classmethod
+    def is_builtin(cls, name: str) -> bool:
+        """Check if a plugin is builtin."""
+        return name in cls._plugins
+
+
+def register_builtin_plugin(name: str):
+    """Decorator to register a plugin as builtin."""
+
+    def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
+        BuiltinPluginRegistry.register(name, plugin_class)
+        return plugin_class
+
+    return decorator
+
+
+def load_builtin_plugin(name: str) -> Optional[Plugin]:
+    """Load a builtin plugin by name."""
+    plugin_class = BuiltinPluginRegistry.get_plugin_class(name)
+    if plugin_class:
+        return plugin_class()
+    return None
+
+
+# Note: External plugin packages can be registered here if needed
+# For example, to auto-register plugins from external packages:
+# try:
+#     from external_package.plugins import SomePlugin
+#     BuiltinPluginRegistry.register("some_plugin", SomePlugin)
+# except ImportError:
+#     # external_package not available, skip registration
+#     pass

janito/plugins/tools/local/__init__.py

@@ -1,80 +1,82 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .read_files import ReadFilesTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-from .read_chart import ReadChartTool
-from .show_image import ShowImageTool
-from .show_image_grid import ShowImageGridTool
-
-from janito.tools.tool_base import ToolPermissions
-import os
-from janito.tools.permissions import get_global_allowed_permissions
-from janito.platform_discovery import PlatformDiscovery
-
-# Singleton tools adapter with all standard tools registered
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
-
-
-def get_local_tools_adapter(workdir=None):
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-
-# Register tools
-pd = PlatformDiscovery()
-is_powershell = pd.detect_shell().startswith("PowerShell")
-
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    ReadFilesTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-    ReadChartTool,
-    ShowImageTool,
-    ShowImageGridTool,
-]:
-    # Skip bash tools when running in PowerShell
-    if is_powershell and tool_class.__name__ in ["RunBashCommandTool"]:
-        continue
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .read_files import ReadFilesTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+from .read_chart import ReadChartTool
+from .show_image import ShowImageTool
+from .show_image_grid import ShowImageGridTool
+from .markdown_view import MarkdownViewTool
+
+from janito.tools.tool_base import ToolPermissions
+import os
+from janito.tools.permissions import get_global_allowed_permissions
+from janito.platform_discovery import PlatformDiscovery
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+
+def get_local_tools_adapter(workdir=None):
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+
+# Register tools
+pd = PlatformDiscovery()
+is_powershell = pd.detect_shell().startswith("PowerShell")
+
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    ReadFilesTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+    ReadChartTool,
+    ShowImageTool,
+    ShowImageGridTool,
+    MarkdownViewTool,
+]:
+    # Skip bash tools when running in PowerShell
+    if is_powershell and tool_class.__name__ in ["RunBashCommandTool"]:
+        continue
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup

janito/plugins/tools/local/markdown_view.py

@@ -0,0 +1,94 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.plugins.tools.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class MarkdownViewTool(ToolBase):
+    """
+    Display markdown content in the terminal using rich markdown rendering.
+
+    Args:
+        path (str): Path to the markdown file to display.
+        width (int, optional): Display width. Defaults to 80.
+        theme (str, optional): Markdown theme. Defaults to "github".
+
+    Returns:
+        str: Status message indicating the result of the markdown display.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "markdown_view"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str, width: int = 80, theme: str = "github") -> str:
+        import os
+        from janito.tools.path_utils import expand_path
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        
+        self.report_action(
+            tr("📖 View markdown '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
+        
+        try:
+            if not os.path.exists(path):
+                return f"❌ Error: File not found at '{path}'"
+                
+            if not path.lower().endswith(('.md', '.markdown')):
+                return f"⚠️ Warning: File '{path}' does not appear to be a markdown file"
+
+            # Read the markdown file
+            with open(path, 'r', encoding='utf-8', errors='replace') as f:
+                markdown_content = f.read()
+
+            if not markdown_content.strip():
+                return f"⚠️ Warning: Markdown file '{path}' is empty"
+
+            # Import rich components for markdown rendering
+            try:
+                from rich.console import Console
+                from rich.markdown import Markdown
+                from rich.panel import Panel
+                from rich.text import Text
+            except ImportError:
+                return "❌ Error: rich library not available for markdown rendering"
+
+            # Create console with specified width
+            console = Console(width=width)
+            
+            # Create markdown object
+            markdown = Markdown(markdown_content)
+            
+            # Display the markdown with a header
+            console.print(f"\n[bold cyan]📄 Markdown: {disp_path}[/bold cyan]")
+            console.print("=" * min(len(disp_path) + 15, width))
+            console.print()
+            
+            # Render the markdown content
+            console.print(markdown)
+            console.print()
+            
+            self.report_success(
+                tr(" ✅ Markdown displayed: {disp_path}", disp_path=disp_path)
+            )
+            
+            return f"✅ Markdown displayed: {disp_path}"
+
+        except FileNotFoundError:
+            self.report_warning(tr("❗ not found"))
+            return f"❌ Error: File not found at '{path}'"
+        except PermissionError:
+            self.report_error(tr(" ❌ Permission denied: {path}", path=disp_path))
+            return f"❌ Error: Permission denied reading '{path}'"
+        except UnicodeDecodeError as e:
+            self.report_error(tr(" ❌ Encoding error: {error}", error=e))
+            return f"❌ Error: Unable to decode file '{path}' - {e}"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return f"❌ Error displaying markdown: {e}"

janito/plugins/tools/local/show_image.py

@@ -1,74 +1,119 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.local.adapter import register_local_tool
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-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
-
-        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()
-            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)
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.plugins.tools.local.adapter import register_local_tool
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+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
+
+        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()
+            from rich.panel import Panel
+            from rich.text import Text
+            import numpy as np
+            
+            img = PILImage.open(path)
+            
+            # Create ASCII art representation
+            def image_to_ascii(image, width=40, height=20):
+                try:
+                    # Convert to grayscale and resize
+                    img_gray = image.convert('L')
+                    img_resized = img_gray.resize((width, height))
+                    
+                    # Convert to numpy array
+                    pixels = np.array(img_resized)
+                    
+                    # ASCII characters from dark to light
+                    ascii_chars = "@%#*+=-:. "
+                    
+                    # Normalize pixels to ASCII range
+                    ascii_art = ""
+                    for row in pixels:
+                        for pixel in row:
+                            # Map pixel value (0-255) to ASCII index
+                            ascii_index = int((pixel / 255) * (len(ascii_chars) - 1))
+                            ascii_art += ascii_chars[ascii_index]
+                        ascii_art += "\n"
+                    
+                    return ascii_art.strip()
+                except Exception:
+                    return None
+            
+            # Calculate appropriate size for terminal display
+            display_width = width or min(60, img.width // 4)
+            display_height = height or min(30, img.height // 4)
+            
+            ascii_art = image_to_ascii(img, display_width, display_height)
+            
+            if ascii_art:
+                # Create a panel with both info and ASCII art
+                img_info = Text(f"🖼️ {disp_path}\nSize: {img.width}×{img.height}\nMode: {img.mode}\n", style="bold green")
+                ascii_text = Text(ascii_art, style="dim")
+                combined = Text.assemble(img_info, ascii_text)
+                panel = Panel(combined, title="Image Preview", border_style="blue")
+            else:
+                # Fallback to just info if ASCII art fails
+                img_info = Text(f"🖼️ {disp_path}\nSize: {img.width}×{img.height}\nMode: {img.mode}", style="bold green")
+                panel = Panel(img_info, title="Image Info", border_style="blue")
+            
+            console.print(panel)
+            
+            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)