janito 2.30.0__tar.gz → 2.31.1__tar.gz

{janito-2.30.0 → janito-2.31.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.30.0
+Version: 2.31.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -19,6 +19,7 @@ Requires-Dist: requests>=2.32.4
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: openai>=1.68.0
+Requires-Dist: Pillow>=10.0.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"

{janito-2.30.0 → janito-2.31.1}/docs/plugins/ACTUAL_TOOLS_LOCATION.md

@@ -39,6 +39,9 @@ janito/tools/adapters/local/
 | `python_file_run` | `janito/tools/adapters/local/python_file_run.py` | Python script execution |
 | **dev.visualization** | | |
 | `read_chart` | `janito/tools/adapters/local/read_chart.py` | Data visualization |
+| **core.imagedisplay** | | |
+| `show_image` | `janito/tools/adapters/local/show_image.py` | Display single image |
+| `show_image_grid` | `janito/tools/adapters/local/show_image_grid.py` | Display multiple images in a grid |
 | **ui.userinterface** | | |
 | `ask_user` | `janito/tools/adapters/local/ask_user.py` | User interaction |
 

{janito-2.30.0 → janito-2.31.1}/docs/plugins/built-in-plugins/filemanager.md

@@ -25,6 +25,10 @@ The File Manager plugin provides essential file and directory operations for man
 ## Usage Examples
 
 ### Creating a New File
+
+The `create_file` tool provides comprehensive file creation with built-in safety features and automatic validation.
+
+**Basic Usage:**
 ```json
 {
   "tool": "create_file",
@@ -33,6 +37,51 @@ The File Manager plugin provides essential file and directory operations for man
 }
 ```
 
+**Advanced Examples:**
+
+Create nested directory structure:
+```json
+{
+  "tool": "create_file",
+  "path": "src/components/Button/index.js",
+  "content": "export default function Button() { return <button>Click me</button>; }"
+}
+```
+
+Create configuration file with environment variables:
+```json
+{
+  "tool": "create_file",
+  "path": "$HOME/.myapp/config.json",
+  "content": "{\n  \"api_url\": \"https://api.example.com\",\n  \"timeout\": 30\n}"
+}
+```
+
+Overwrite existing file (use with caution):
+```json
+{
+  "tool": "create_file",
+  "path": "README.md",
+  "content": "# My Project\n\nUpdated documentation...",
+  "overwrite": true
+}
+```
+
+**Safety Features:**
+
+- **Overwrite Protection**: Prevents accidental file overwrites by default
+- **Syntax Validation**: Automatically checks Python, JavaScript, JSON, YAML, and other common file types
+- **Path Expansion**: Supports `~` for home directory and environment variables like `$HOME`
+- **Directory Creation**: Automatically creates parent directories as needed
+- **Encoding Safety**: Uses UTF-8 encoding with proper error handling for international characters
+- **Loop Protection**: Prevents excessive file creation calls (max 5 per 10 seconds per file)
+
+**Return Values:**
+
+- Success: Includes line count and syntax validation results
+- Failure: Provides detailed error messages and existing content preview when overwrite is blocked
+- Validation: Shows syntax check results for supported file types
+
 ### Reading Multiple Files
 ```json
 {

janito-2.31.1/docs/plugins/built-in-plugins/imagedisplay.md

@@ -0,0 +1,19 @@
+# Image Display Plugin (core.imagedisplay)
+
+Display images inline in the terminal using the rich library.
+
+Tools provided:
+
+- show_image: display a single image
+- show_image_grid: display multiple images in a grid
+
+Dependencies:
+
+- rich
+- pillow
+
+Example:
+
+```bash
+janito --tool show_image --path img/tux.png --width 60
+```

{janito-2.30.0 → janito-2.31.1}/docs/plugins/built-in-plugins/visualization.md

@@ -11,6 +11,8 @@ The Visualization plugin provides data visualization and charting capabilities.
 | Tool Name | Function | Description |
 |-----------|----------|-------------|
 | `read_chart` | Display charts in terminal | Renders various chart types (bar, line, pie, table) in the terminal using rich formatting |
+| `show_image` | Display single image | Shows a single image inline in the terminal using rich |
+| `show_image_grid` | Display image grid | Shows multiple images in a grid inline in the terminal |
 
 ## Usage Examples
 
@@ -69,6 +71,11 @@ The Visualization plugin provides data visualization and charting capabilities.
 
 This plugin does not require any specific configuration. Chart rendering uses default dimensions and styling.
 
+Image Display tools (core.imagedisplay) have optional settings:
+- default_width (int): Default width for image display
+- default_height (int): Default height for image display
+- preserve_aspect (bool): Preserve aspect ratio by default
+
 ## Security Considerations
 
 - Chart data is rendered client-side with no external dependencies

{janito-2.30.0 → janito-2.31.1}/docs/plugins/configuration.md

@@ -14,6 +14,7 @@ Plugins can be configured through the main configuration file `janito.json`. The
     "load": {
       "core.filemanager": true,
       "core.codeanalyzer": true,
+      "core.imagedisplay": true,
       "web.webtools": false
     },
     "config": {
@@ -41,7 +42,8 @@ The `plugins.load` section controls which plugins are enabled:
   "load": {
     "core.filemanager": true,
     "dev.pythondev": true,
-    "ui.userinterface": true
+    "ui.userinterface": true,
+    "core.imagedisplay": true
   }
 }
 ```

janito-2.31.1/docs/tools/show-image-grid.md

@@ -0,0 +1,19 @@
+# show_image_grid
+
+Display multiple images in a grid inline in the terminal using rich.
+
+Arguments:
+
+- 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:
+
+- Status string summarizing the grid display.
+
+Example Usage:
+
+- `show_image_grid(paths=["img/tux.png", "img/tux_display.png"], columns=2, width=40)`

janito-2.31.1/docs/tools/show-image.md

@@ -0,0 +1,16 @@
+# show_image
+
+Display an image inline in the terminal using the rich library.
+
+Arguments:
+- 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:
+- Status message indicating display result or error details.
+
+Example Usage:
+- show a PNG: `show_image(path="img/tux.png", width=60)`
+- auto-fit: `show_image(path="~/Pictures/photo.jpg")`

{janito-2.30.0 → janito-2.31.1}/docs/tools-index.md

@@ -6,6 +6,39 @@ Janito provides a comprehensive set of tools for file operations, code execution
 
 ### Visualization Tools
 
+#### show_image
+
+Display an image inline in the terminal using rich.
+
+Arguments:
+- 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:
+- Status message indicating display result or error details.
+
+Example Usage:
+- show a PNG: `show_image(path="img/tux.png", width=60)`
+
+#### show_image_grid
+
+Display multiple images in a grid inline in the terminal using rich.
+
+Arguments:
+- 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:
+- Status string summarizing the grid display.
+
+Example Usage:
+- `show_image_grid(paths=["img/tux.png", "img/tux_display.png"], columns=2, width=40)`
+
 #### read_chart
 
 Display charts and data visualizations in the terminal using rich.

janito-2.31.1/janito/cli/cli_commands/list_plugins.py

@@ -0,0 +1,228 @@
+"""
+CLI command to list available and loaded plugins.
+"""
+
+import argparse
+from typing import List, Dict, Any
+from janito.plugins.discovery import list_available_plugins
+import os
+from janito.plugins.manager import PluginManager
+from janito.plugins.builtin import BuiltinPluginRegistry
+from janito.plugins.auto_loader_fixed import load_core_plugins, get_loaded_core_plugins, is_core_plugin
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+
+def handle_list_plugins(args: argparse.Namespace) -> None:
+    """List plugins command handler."""
+
+    if getattr(args, "list_plugins_available", False):
+        _list_available_plugins()
+    elif getattr(args, "list_resources", False):
+        _list_plugin_resources()
+    else:
+        _list_loaded_plugins()
+
+
+def _list_available_plugins():
+    """List available plugins using rich formatting."""
+    console = Console()
+    available = list_available_plugins()
+    builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
+
+    if available or builtin_plugins:
+        # Create main table
+        table = Table(title="Available Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Type", style="magenta")
+        table.add_column("Status", style="green")
+
+        # Add builtin plugins
+        for plugin in builtin_plugins:
+            table.add_row(plugin, "Builtin", "📦")
+
+        # Add external plugins
+        other_plugins = [p for p in available if p not in builtin_plugins]
+        for plugin in other_plugins:
+            table.add_row(plugin, "External", "🔌")
+
+        console.print(table)
+
+        # Show core plugins
+        from janito.plugins.core_loader_fixed import get_core_plugins
+        core_plugins = get_core_plugins()
+        core_table = Table(title="Core Plugins (Enabled by Default)")
+        core_table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        core_table.add_column("Status", style="yellow")
+
+        for plugin in core_plugins:
+            core_table.add_row(plugin, "✅ Available")
+
+        console.print(core_table)
+    else:
+        console.print(Panel(
+            "No plugins found in search paths\n"
+            f"[dim]Search paths:[/dim]\n"
+            f"  • {os.getcwd()}/plugins\n"
+            f"  • {os.path.expanduser('~')}/.janito/plugins",
+            title="No Plugins Found",
+            style="yellow"
+        ))
+
+
+def _print_builtin_plugins(builtin_plugins):
+    """Print builtin plugins."""
+    if builtin_plugins:
+        print("  Builtin plugins:")
+        for plugin in builtin_plugins:
+            print(f"    - {plugin} [BUILTIN]")
+
+
+def _print_external_plugins(available, builtin_plugins):
+    """Print external plugins."""
+    other_plugins = [p for p in available if p not in builtin_plugins]
+    if other_plugins:
+        print("  External plugins:")
+        for plugin in other_plugins:
+            print(f"    - {plugin}")
+
+
+def _list_plugin_resources():
+    """List all resources from loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
+    all_resources = manager.list_all_resources()
+
+    if all_resources:
+        for plugin_name, resources in all_resources.items():
+            metadata = manager.get_plugin_metadata(plugin_name)
+            version = metadata.version if metadata else 'unknown'
+            
+            # Create panel for each plugin
+            panel_content = []
+            
+            tools = [r for r in resources if r["type"] == "tool"]
+            commands = [r for r in resources if r["type"] == "command"]
+            configs = [r for r in resources if r["type"] == "config"]
+
+            if tools:
+                panel_content.append("[bold blue]Tools:[/bold blue]")
+                for tool in tools:
+                    panel_content.append(f"  • {tool['name']}: {tool['description']}")
+
+            if commands:
+                panel_content.append("[bold green]Commands:[/bold green]")
+                for cmd in commands:
+                    panel_content.append(f"  • {cmd['name']}: {cmd['description']}")
+
+            if configs:
+                panel_content.append("[bold yellow]Configuration:[/bold yellow]")
+                for config in configs:
+                    panel_content.append(f"  • {config['name']}: {config['description']}")
+
+            console.print(Panel(
+                "\n".join(panel_content),
+                title=f"{plugin_name} v{version}",
+                style="cyan"
+            ))
+    else:
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugin Resources",
+            style="yellow"
+        ))
+
+
+def _print_resources_by_type(resources):
+    """Print resources grouped by type."""
+    tools = [r for r in resources if r["type"] == "tool"]
+    commands = [r for r in resources if r["type"] == "command"]
+    configs = [r for r in resources if r["type"] == "config"]
+
+    if tools:
+        print("  Tools:")
+        for tool in tools:
+            print(f"    - {tool['name']}: {tool['description']}")
+
+    if commands:
+        print("  Commands:")
+        for cmd in commands:
+            print(f"    - {cmd['name']}: {cmd['description']}")
+
+    if configs:
+        print("  Configuration:")
+        for config in configs:
+            print(f"    - {config['name']}: {config['description']}")
+
+
+def _list_loaded_plugins():
+    """List loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
+    loaded = manager.list_plugins()
+
+    if loaded:
+        # Create main table
+        table = Table(title="Loaded Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Version", style="magenta")
+        table.add_column("Description", style="green", max_width=50)
+        table.add_column("Type", style="yellow")
+
+        core_plugins = []
+        other_plugins = []
+        
+        for plugin_name in loaded:
+            if is_core_plugin(plugin_name):
+                core_plugins.append(plugin_name)
+            else:
+                other_plugins.append(plugin_name)
+        
+        # Add core plugins
+        for plugin_name in core_plugins:
+            metadata = manager.get_plugin_metadata(plugin_name)
+            if metadata:
+                table.add_row(
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔵 Core"
+                )
+        
+        # Add other plugins
+        for plugin_name in other_plugins:
+            metadata = manager.get_plugin_metadata(plugin_name)
+            if metadata:
+                table.add_row(
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔶 External"
+                )
+
+        console.print(table)
+    else:
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugins Loaded",
+            style="yellow"
+        ))
+
+
+def _print_plugin_details(manager, plugin_name):
+    """Print details for a loaded plugin."""
+    metadata = manager.get_plugin_metadata(plugin_name)
+    is_builtin = BuiltinPluginRegistry.is_builtin(plugin_name)
+    if metadata:
+        builtin_tag = " [BUILTIN]" if is_builtin else ""
+        print(f"  - {metadata.name} v{metadata.version}{builtin_tag}")
+        print(f"    {metadata.description}")
+        if metadata.author:
+            print(f"    Author: {metadata.author}")
+        print()

{janito-2.30.0 → janito-2.31.1}/janito/cli/rich_terminal_reporter.py

@@ -161,7 +161,7 @@ class RichTerminalReporter(EventHandlerBase):
             self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDOUT:
-            self.console.print(Text(msg, style="on dark_green"))
+            self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDERR:
             self.console.print(Text(msg, style="on red"))

janito-2.31.1/janito/plugins/auto_loader.py

@@ -0,0 +1,91 @@
+"""
+Auto-loader for core plugins.
+
+This module automatically loads core plugins when the plugin system is initialized.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+from janito.plugins.manager import PluginManager
+from janito.plugins.discovery import list_available_plugins
+
+# List of core plugins that should be enabled by default
+CORE_PLUGINS = [
+    "core.filemanager",
+    "core.codeanalyzer", 
+    "core.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+def load_core_plugins(pm: PluginManager = None) -> List[str]:
+    """
+    Load all core plugins.
+    
+    Args:
+        pm: PluginManager instance. If None, creates a new one.
+        
+    Returns:
+        List of successfully loaded plugin names
+    """
+    if pm is None:
+        pm = PluginManager()
+    
+    # Ensure plugins directory is in search path
+    plugins_dir = Path.cwd() / "plugins"
+    if plugins_dir.exists():
+        pm.add_plugin_path(str(plugins_dir))
+    
+    loaded = []
+    
+    # Load core plugins
+    for plugin_name in CORE_PLUGINS:
+        try:
+            if pm.load_plugin(plugin_name):
+                loaded.append(plugin_name)
+        except Exception as e:
+            print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
+    
+    return loaded
+
+
+def get_loaded_core_plugins() -> List[str]:
+    """
+    Get list of currently loaded core plugins.
+    
+    Returns:
+        List of loaded core plugin names
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+def is_core_plugin(plugin_name: str) -> bool:
+    """
+    Check if a plugin is a core plugin.
+    
+    Args:
+        plugin_name: Name of the plugin to check
+        
+    Returns:
+        True if it's a core plugin
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# Auto-load core plugins when module is imported
+_plugin_manager = None
+
+def get_plugin_manager() -> PluginManager:
+    """Get the global plugin manager with core plugins loaded."""
+    global _plugin_manager
+    if _plugin_manager is None:
+        _plugin_manager = PluginManager()
+        load_core_plugins(_plugin_manager)
+    return _plugin_manager

janito-2.31.1/janito/plugins/auto_loader_fixed.py

@@ -0,0 +1,90 @@
+"""
+Fixed auto-loader for core plugins.
+
+This module provides a working implementation to load core plugins
+without the complex discovery mechanism.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+from janito.plugins.manager import PluginManager
+from janito.plugins.core_loader_fixed import load_core_plugin, get_core_plugins
+
+# List of core plugins that should be enabled by default
+CORE_PLUGINS = [
+    "core.filemanager",
+    "core.codeanalyzer", 
+    "core.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+def load_core_plugins(pm: PluginManager = None) -> List[str]:
+    """
+    Load all core plugins.
+    
+    Args:
+        pm: PluginManager instance. If None, creates a new one.
+        
+    Returns:
+        List of successfully loaded plugin names
+    """
+    if pm is None:
+        pm = PluginManager()
+    
+    loaded = []
+    
+    # Load core plugins
+    for plugin_name in CORE_PLUGINS:
+        try:
+            plugin = load_core_plugin(plugin_name)
+            if plugin:
+                # Manually register the plugin
+                pm.plugins[plugin_name] = plugin
+                loaded.append(plugin_name)
+        except Exception as e:
+            print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
+    
+    return loaded
+
+
+def get_loaded_core_plugins() -> List[str]:
+    """
+    Get list of currently loaded core plugins.
+    
+    Returns:
+        List of loaded core plugin names
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+def is_core_plugin(plugin_name: str) -> bool:
+    """
+    Check if a plugin is a core plugin.
+    
+    Args:
+        plugin_name: Name of the plugin to check
+        
+    Returns:
+        True if it's a core plugin
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# Auto-load core plugins when module is imported
+_plugin_manager = None
+
+def get_plugin_manager() -> PluginManager:
+    """Get the global plugin manager with core plugins loaded."""
+    global _plugin_manager
+    if _plugin_manager is None:
+        _plugin_manager = PluginManager()
+        load_core_plugins(_plugin_manager)
+    return _plugin_manager