janito 2.27.0__tar.gz → 2.27.1__tar.gz

{janito-2.27.0 → janito-2.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.27.0
+Version: 2.27.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -28,6 +28,8 @@ Requires-Dist: codespell==2.4.1; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: questionary>=2.0.1; extra == "dev"
 Requires-Dist: setuptools_scm>=8.0; extra == "dev"
+Provides-Extra: coder
+Requires-Dist: janito-coder; extra == "coder"
 Dynamic: license-file
 
 # Janito, control you context

janito-2.27.1/docs/plugins/ACTUAL_TOOLS_LOCATION.md

@@ -0,0 +1,49 @@
+# Actual Tools Location
+
+## Real Tool Implementations
+
+The actual tool implementations are located in:
+```
+janito/tools/adapters/local/
+```
+
+## Tool Mapping
+
+| Plugin Name | Actual Tool File | Description |
+|-------------|------------------|-------------|
+| **core.filemanager** | | |
+| `create_file` | `janito/tools/adapters/local/create_file.py` | Create new files |
+| `read_files` | `janito/tools/adapters/local/read_files.py` | Read multiple files |
+| `view_file` | `janito/tools/adapters/local/view_file.py` | Read file contents |
+| `replace_text_in_file` | `janito/tools/adapters/local/replace_text_in_file.py` | Find and replace text |
+| `validate_file_syntax` | `janito/tools/adapters/local/validate_file_syntax/` | Syntax validation |
+| `create_directory` | `janito/tools/adapters/local/create_directory.py` | Create directories |
+| `remove_directory` | `janito/tools/adapters/local/remove_directory.py` | Remove directories |
+| `remove_file` | `janito/tools/adapters/local/remove_file.py` | Delete files |
+| `copy_file` | `janito/tools/adapters/local/copy_file.py` | Copy files/directories |
+| `move_file` | `janito/tools/adapters/local/move_file.py` | Move/rename files |
+| `find_files` | `janito/tools/adapters/local/find_files.py` | Search for files |
+| **core.codeanalyzer** | | |
+| `get_file_outline` | `janito/tools/adapters/local/get_file_outline/` | File structure analysis |
+| `search_outline` | `janito/tools/adapters/local/get_file_outline/search_outline.py` | Search in outlines |
+| `search_text` | `janito/tools/adapters/local/search_text/` | Text search |
+| **core.system** | | |
+| `run_powershell_command` | `janito/tools/adapters/local/run_powershell_command.py` | PowerShell execution |
+| **web.webtools** | | |
+| `fetch_url` | `janito/tools/adapters/local/fetch_url.py` | Web scraping |
+| `open_url` | `janito/tools/adapters/local/open_url.py` | Open URLs |
+| `open_html_in_browser` | `janito/tools/adapters/local/open_html_in_browser.py` | Open HTML files |
+| **dev.pythondev** | | |
+| `python_code_run` | `janito/tools/adapters/local/python_code_run.py` | Python execution |
+| `python_command_run` | `janito/tools/adapters/local/python_command_run.py` | Python -c execution |
+| `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 |
+| **ui.userinterface** | | |
+| `ask_user` | `janito/tools/adapters/local/ask_user.py` | User interaction |
+
+## Architecture Note
+
+The plugin system in `plugins/` contains **interface definitions and wrappers**, while the actual tool implementations are in `janito/tools/adapters/local/`. 
+
+The real tools are implemented as classes inheriting from `ToolBase` and registered via decorators like `@register_local_tool`.

janito-2.27.1/docs/plugins/MIGRATION_COMPLETE.md

@@ -0,0 +1,73 @@
+# Tool Migration Complete ✅
+
+## Summary
+
+All 23 tools have been successfully organized in the plugin structure in `plugins/`. The actual implementations remain in `janito/tools/adapters/local/` as the source of truth.
+
+## Migration Results
+
+> [!NOTE]
+> The actual tool implementations remain in `janito/tools/adapters/local/` as the source of truth. The plugin system provides organized interfaces.
+
+### 📁 File Manager Plugin (`plugins/core/filemanager/tools/`)
+
+- ✅ copy_file.py
+- ✅ create_directory.py  
+- ✅ create_file.py
+- ✅ find_files.py
+- ✅ move_file.py
+- ✅ read_files.py
+- ✅ remove_directory.py
+- ✅ remove_file.py
+- ✅ replace_text_in_file.py
+- ✅ validate_file_syntax/ (directory)
+- ✅ view_file.py
+
+### 🔍 Code Analyzer Plugin (`plugins/core/codeanalyzer/tools/`)
+
+- ✅ get_file_outline/ (directory)
+- ✅ search_text/ (directory)
+
+### ⚡ System Tools Plugin (`plugins/core/system/tools/`)
+
+- ✅ run_powershell_command.py
+
+### 🌐 Web Tools Plugin (`plugins/web/webtools/tools/`)
+- ✅ fetch_url.py
+- ✅ open_html_in_browser.py
+- ✅ open_url.py
+
+### 🐍 Python Dev Plugin (`plugins/dev/pythondev/tools/`)
+- ✅ python_code_run.py
+- ✅ python_command_run.py
+- ✅ python_file_run.py
+
+### 📊 Visualization Plugin (`plugins/dev/visualization/tools/`)
+- ✅ read_chart.py
+
+### 💬 User Interface Plugin (`plugins/ui/userinterface/tools/`)
+- ✅ ask_user.py
+
+## Total Files Moved
+- **23 tools** successfully relocated
+- **All directories** created and organized
+- **Original files** remain in `janito/tools/adapters/local/` (copies made)
+
+## Plugin Structure
+
+```
+plugins/
+├── core/
+│   ├── filemanager/tools/     # 11 tools
+│   ├── codeanalyzer/tools/    # 3 tools  
+│   └── system/tools/          # 1 tool
+├── web/
+│   └── webtools/tools/        # 3 tools
+├── dev/
+│   ├── pythondev/tools/       # 3 tools
+│   └── visualization/tools/   # 1 tool
+└── ui/
+    └── userinterface/tools/   # 1 tool
+```
+
+The tools are now organized by functional domain and ready for plugin-based usage!

janito-2.27.1/docs/plugins/api-reference.md

@@ -0,0 +1,221 @@
+# Plugin API Reference
+
+## Overview
+
+This document provides a comprehensive reference for the Janito plugin API. It details the classes, methods, and interfaces available for plugin development.
+
+## Core Classes
+
+### PluginMetadata
+
+Data class containing plugin metadata.
+
+```python
+@dataclass
+class PluginMetadata:
+    name: str                    # Unique plugin identifier
+    version: str                 # Semantic version (e.g., "1.0.0")
+    description: str             # Brief description of the plugin
+    author: str                  # Plugin author name
+    license: str = "MIT"         # Software license
+    homepage: Optional[str] = None  # URL to plugin documentation
+    dependencies: List[str] = None  # List of required packages
+```
+
+### PluginResource
+
+Represents a resource provided by a plugin.
+
+```python
+@dataclass
+class PluginResource:
+    name: str                    # Resource name
+    type: str                    # Resource type ("tool", "command", "config")
+    description: str             # Resource description
+    schema: Optional[Dict[str, Any]] = None  # JSON schema for config resources
+```
+
+### Plugin (Abstract Base Class)
+
+Base class for all plugins.
+
+```python
+class Plugin(ABC):
+    def __init__(self):
+        self.metadata: PluginMetadata = self.get_metadata()
+    
+    @abstractmethod
+    def get_metadata(self) -> PluginMetadata:
+        """Return metadata describing this plugin."""
+    
+    def get_tools(self) -> List[Type[ToolBase]]:
+        """Return a list of tool classes provided by this plugin."""
+    
+    def get_commands(self) -> Dict[str, Any]:
+        """Return a dictionary of CLI commands provided by this plugin."""
+    
+    def initialize(self) -> None:
+        """Called when the plugin is loaded. Override for initialization."""
+    
+    def cleanup(self) -> None:
+        """Called when the plugin is unloaded. Override for cleanup."""
+    
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Return JSON schema for plugin configuration."""
+    
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """Validate plugin configuration."""
+    
+    def get_resources(self) -> List[PluginResource]:
+        """Return a list of resources provided by this plugin."""
+```
+
+## Plugin Lifecycle
+
+### Initialization
+
+The `initialize()` method is called when the plugin is loaded:
+
+```python
+def initialize(self) -> None:
+    """Called when the plugin is loaded."""
+    # Perform any setup needed
+    self.setup_database_connection()
+    self.load_configuration()
+```
+
+### Cleanup
+
+The `cleanup()` method is called when the plugin is unloaded:
+
+```python
+def cleanup(self) -> None:
+    """Called when the plugin is unloaded."""
+    # Perform any cleanup needed
+    self.close_database_connection()
+    self.cleanup_temp_files()
+```
+
+## Resource Contribution Methods
+
+### get_tools()
+
+Returns a list of tool classes that should be registered:
+
+```python
+def get_tools(self) -> List[Type[ToolBase]]:
+    return [MyTool1, MyTool2, MyTool3]
+```
+
+### get_commands()
+
+Returns a dictionary mapping command names to handler functions:
+
+```python
+def get_commands(self) -> Dict[str, Any]:
+    return {
+        "mycommand": self.handle_mycommand,
+        "another-command": self.handle_another_command
+    }
+```
+
+### get_config_schema()
+
+Returns a JSON schema describing the plugin's configuration options:
+
+```python
+def get_config_schema(self) -> Dict[str, Any]:
+    return {
+        "type": "object",
+        "properties": {
+            "timeout": {
+                "type": "number",
+                "minimum": 1,
+                "maximum": 3600,
+                "default": 30
+            },
+            "api_key": {
+                "type": "string",
+                "minLength": 32
+            }
+        },
+        "required": ["api_key"]
+    }
+```
+
+## Utility Methods
+
+### get_config()
+
+Retrieves the plugin's current configuration:
+
+```python
+def get_config(self) -> Dict[str, Any]:
+    """Get the current plugin configuration."""
+    # Implementation provided by the plugin system
+    pass
+```
+
+### report_action()
+
+Logs an action performed by a tool (available in ToolBase):
+
+```python
+def report_action(self, message: str, action_type: str = "action") -> None:
+    """Report an action performed by the tool."""
+    # Implementation provided by the base class
+    pass
+```
+
+## Best Practices
+
+### Error Handling
+
+Always include proper error handling in your tools:
+
+```python
+class MyTool(ToolBase):
+    def run(self, param: str) -> str:
+        try:
+            # Your logic here
+            result = some_operation(param)
+            return f"Success: {result}"
+        except ValueError as e:
+            return f"Error: Invalid parameter - {str(e)}"
+        except Exception as e:
+            return f"Error: Operation failed - {str(e)}"
+```
+
+### Documentation
+
+Include comprehensive docstrings for all methods:
+
+```python
+def run(self, name: str = "World") -> str:
+    """
+    Generate a greeting message.
+    
+    Args:
+        name: Name of the person to greet (default: "World")
+    
+    Returns:
+        Formatted greeting message
+    
+    Examples:
+        >>> tool = GreetingTool()
+        >>> tool.run("Alice")
+        'Hello, Alice!'
+    """
+```
+
+### Security
+
+Follow security best practices:
+
+- Validate all inputs
+- Use appropriate permissions for tools
+- Sanitize user input
+- Implement timeouts for long-running operations
+- Avoid executing untrusted code
+
+This API reference provides the complete interface for developing plugins, enabling you to create powerful extensions that integrate seamlessly with the Janito system.

janito-2.27.1/docs/plugins/architecture.md

@@ -0,0 +1,128 @@
+# Plugin Architecture
+
+## Overview
+
+The Janito plugin architecture is designed to provide a flexible and extensible system for adding functionality. The architecture separates the interface definitions from the actual implementations, allowing for organized plugin management while maintaining a clean codebase.
+
+## Architecture Components
+
+### Plugin Interface Layer
+
+Located in the `plugins/` directory, this layer contains the plugin definitions and interfaces. Each plugin is organized by functional domain:
+
+```
+plugins/
+├── core/           # Core system functionality
+│   ├── filemanager/
+│   ├── codeanalyzer/
+│   └── system/
+├── web/            # Web-related functionality
+│   └── webtools/
+├── dev/            # Development tools
+│   ├── pythondev/
+│   └── visualization/
+└── ui/             # User interface
+    └── userinterface/
+```
+
+### Implementation Layer
+
+The actual tool implementations are located in `janito/tools/adapters/local/`. This separation ensures that the core functionality remains stable while the plugin interfaces can be organized and extended.
+
+```
+janito/tools/adapters/local/
+├── create_file.py
+├── read_files.py
+├── view_file.py
+├── replace_text_in_file.py
+├── validate_file_syntax/
+├── create_directory.py
+├── remove_directory.py
+├── remove_file.py
+├── copy_file.py
+├── move_file.py
+├── find_files.py
+├── get_file_outline/
+├── search_text/
+├── run_powershell_command.py
+├── fetch_url.py
+├── open_url.py
+├── open_html_in_browser.py
+├── python_code_run.py
+├── python_command_run.py
+├── python_file_run.py
+├── read_chart.py
+└── ask_user.py
+```
+
+## Resource Flow
+
+1. **Plugin Registration**: Plugins are registered with the system at startup
+2. **Tool Discovery**: The system discovers available tools from registered plugins
+3. **Resource Contribution**: Each plugin contributes its tools to the global tool registry
+4. **Tool Execution**: When a tool is called, the system routes the request to the appropriate implementation
+
+## Plugin Loading Process
+
+1. **Discovery**: The system scans for plugins in `./plugins/`, `~/.janito/plugins/`, and remote repositories
+2. **Validation**: Plugin metadata and interfaces are validated
+3. **Initialization**: The `initialize()` method is called on each loaded plugin
+4. **Registration**: Tools and commands are registered with the system
+5. **Availability**: Plugins are now available for use
+
+## Resource Contribution Mechanism
+
+Plugins contribute resources through several methods:
+
+### Tools
+
+The primary resource type, tools are registered via the `get_tools()` method:
+
+```python
+def get_tools(self) -> List[Type[ToolBase]]:
+    return [HelloWorldTool, CalculatorTool]
+```
+
+### Commands
+
+CLI commands are contributed through `get_commands()`:
+
+```python
+def get_commands(self) -> Dict[str, Any]:
+    return {"mycommand": my_command_handler}
+```
+
+### Configuration
+
+Plugins can define their configuration schema:
+
+```python
+def get_config_schema(self) -> Dict[str, Any]:
+    return {
+        "type": "object",
+        "properties": {
+            "timeout": {"type": "number", "default": 30}
+        }
+    }
+```
+
+## Security Model
+
+The architecture includes several security features:
+
+- **Permission System**: Each tool has defined read, write, and execute permissions
+- **Path Validation**: File operations include path validation to prevent directory traversal
+- **Sandboxing**: Potentially dangerous operations are sandboxed and monitored
+- **User Confirmation**: Sensitive operations require explicit user approval
+- **Timeouts**: Long-running operations are automatically terminated
+
+## Extension Points
+
+The architecture supports several extension points:
+
+- **New Plugins**: Add new functionality by creating plugins in the `plugins/` directory
+- **Custom Tools**: Implement new tools by extending `ToolBase`
+- **Remote Plugins**: Load plugins from external repositories
+- **Configuration**: Customize plugin behavior through configuration files
+
+This architecture enables a powerful, secure, and extensible system for building AI-assisted development tools.

janito-2.27.1/docs/plugins/built-in-plugins/codeanalyzer.md

@@ -0,0 +1,65 @@
+# Code Analyzer Plugin
+
+## Overview
+
+The Code Analyzer plugin provides tools for understanding and searching code structure. This plugin enables developers to analyze codebases, navigate file structures, and perform advanced text searches across projects.
+
+## Resources Provided
+
+### Tools
+
+| Tool Name | Function | Description |
+|-----------|----------|-------------|
+| `get_file_outline` | Extract file structure | Analyzes a file to identify classes, functions, methods, and other structural elements |
+| `search_outline` | Search within file outlines | Searches for specific structural elements (classes, functions) within file outlines |
+| `search_text` | Full-text search across files | Performs text searches across multiple files with support for regex and case sensitivity |
+
+## Usage Examples
+
+### Getting File Structure
+```json
+{
+  "tool": "get_file_outline",
+  "path": "src/main.py"
+}
+```
+
+### Searching for Functions
+```json
+{
+  "tool": "search_outline",
+  "path": "src/",
+  "query": "function:calculate"
+}
+```
+
+### Finding Code Patterns
+```json
+{
+  "tool": "search_text",
+  "paths": ".",
+  "query": "import requests",
+  "use_regex": false
+}
+```
+
+## Configuration
+
+This plugin does not require any specific configuration and uses default search parameters.
+
+## Security Considerations
+
+- File access is limited to the project directory and subdirectories
+- Respects .gitignore rules to avoid searching in ignored files/directories
+- Large file analysis is rate-limited to prevent performance issues
+
+## Integration
+
+The Code Analyzer plugin integrates with the code intelligence system to provide:
+
+- Code navigation capabilities
+- Structural understanding for AI-assisted coding
+- Pattern recognition for code refactoring suggestions
+- Dependency analysis through import searching
+
+This enables more sophisticated code understanding and manipulation capabilities within the Janito ecosystem.

janito-2.27.1/docs/plugins/built-in-plugins/filemanager.md

@@ -0,0 +1,65 @@
+# File Manager Plugin
+
+## Overview
+
+The File Manager plugin provides essential file and directory operations for managing project files. This plugin enables basic file system operations that are crucial for code editing and project management.
+
+## Resources Provided
+
+### Tools
+
+| Tool Name | Function | Description |
+|-----------|----------|-------------|
+| `create_file` | Create new files with content | Creates a new file at the specified path with optional content and overwrite capability |
+| `read_files` | Read multiple files at once | Reads the contents of multiple files and returns them as a concatenated string |
+| `view_file` | Read specific portions of files | Reads specific lines or the entire content of a file with optional line range |
+| `replace_text_in_file` | Find and replace text in files | Searches for exact text in a file and replaces it with new text (single or all occurrences) |
+| `validate_file_syntax` | Check file syntax | Validates the syntax of various file types (Python, Markdown, JSON, etc.) |
+| `create_directory` | Create new directories | Creates a new directory at the specified path |
+| `remove_directory` | Remove directories | Deletes directories, with optional recursive removal of non-empty directories |
+| `remove_file` | Delete files | Removes a file at the specified path |
+| `copy_file` | Copy files or directories | Copies one or more files/directories to a target location |
+| `move_file` | Move or rename files/directories | Moves or renames files and directories |
+| `find_files` | Search for files by pattern | Finds files matching a pattern in specified directories, respecting .gitignore |
+
+## Usage Examples
+
+### Creating a New File
+```json
+{
+  "tool": "create_file",
+  "path": "src/hello.py",
+  "content": "print('Hello, World!')"
+}
+```
+
+### Reading Multiple Files
+```json
+{
+  "tool": "read_files",
+  "paths": ["src/main.py", "src/utils.py"]
+}
+```
+
+### Finding Python Files
+```json
+{
+  "tool": "find_files",
+  "paths": ".",
+  "pattern": "*.py"
+}
+```
+
+## Configuration
+
+This plugin does not require any specific configuration and uses the system's default file permissions and access controls.
+
+## Security Considerations
+
+- File operations are subject to the user's file system permissions
+- Path validation prevents directory traversal attacks
+- Sensitive file operations require explicit user confirmation in interactive mode
+
+## Integration
+
+The File Manager plugin integrates with the core Janito system to provide file operations that can be used in automation scripts, code generation workflows, and project management tasks.

janito-2.27.1/docs/plugins/built-in-plugins/pythondev.md

@@ -0,0 +1,64 @@
+# Python Development Plugin
+
+## Overview
+
+The Python Development plugin provides tools for Python code execution and development. This plugin enables running Python code in various ways, supporting development, testing, and automation workflows.
+
+## Resources Provided
+
+### Tools
+
+| Tool Name | Function | Description |
+|-----------|----------|-------------|
+| `python_code_run` | Execute Python code via stdin | Runs Python code by passing it to the interpreter via standard input |
+| `python_command_run` | Execute Python with -c flag | Executes Python code using the `python -c` command-line flag |
+| `python_file_run` | Run Python script files | Executes Python scripts from files with configurable timeout |
+
+## Usage Examples
+
+### Running Python Code
+```json
+{
+  "tool": "python_code_run",
+  "code": "print('Hello from Python!')\nfor i in range(3):\n    print(f'Iteration {i}')"
+}
+```
+
+### Executing a One-liner
+```json
+{
+  "tool": "python_command_run",
+  "code": "import sys; print(f'Python {sys.version}')"
+}
+```
+
+### Running a Script File
+```json
+{
+  "tool": "python_file_run",
+  "path": "scripts/data_processor.py",
+  "timeout": 120
+}
+```
+
+## Configuration
+
+This plugin does not require any specific configuration. Python execution uses the system's default Python interpreter and environment.
+
+## Security Considerations
+
+- Code execution requires explicit user permission
+- All Python operations are sandboxed and monitored
+- Long-running scripts are automatically terminated based on timeout settings
+- Access to system resources is controlled through Python's security model
+
+## Integration
+
+The Python Development plugin integrates with the code execution system to provide:
+
+- Interactive Python development environment
+- Automated testing and validation
+- Script-based automation workflows
+- Dynamic code generation and execution
+
+This enables powerful Python-based automation while maintaining security boundaries and user control.