janito 2.26.0__tar.gz → 2.27.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.26.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
@@ -187,7 +189,25 @@ janito -r -w "Read and update this file: ..."
 To enable all permissions (read, write, execute):
 
 ```bash
+# Using individual flags
 janito -r -w -x "Run this code: print('Hello, world!')"
+
+# Using the convenient /rwx prefix (single-shot mode)
+janito /rwx "Run this code: print('Hello, world!')"
+```
+
+#### One-Shot Mode
+For quick tasks without entering interactive mode, provide your prompt directly:
+
+```bash
+# Basic one-shot
+janito "What are the key classes in this project?"
+
+# One-shot with all permissions enabled
+janito /rwx "Create a Python script and run it"
+
+# One-shot with specific permissions
+janito -r -w "Read this file and create a summary"
 ```
 
 > **Warning:** Enabling execution tools allows running arbitrary code or shell commands. Only use `--exec` if you trust your prompt and environment.

{janito-2.26.0 → janito-2.27.1}/README-dev.md

@@ -36,6 +36,32 @@ This document provides guidelines and instructions for developers contributing t
   pip install -e .
   ```
 
+## Release Process
+
+The project includes an automated release script at `tools/release.py` that handles the complete release process:
+
+- **Full release** (build + upload to PyPI):
+  ```sh
+  python tools/release.py
+  ```
+
+- **Build only** (skip PyPI upload):
+  ```sh
+  python tools/release.py --build-only
+  ```
+
+The release script will:
+1. Check for uncommitted changes
+2. Verify the latest git tag version
+3. Check PyPI for existing versions
+4. Build the package using `python -m build`
+5. Upload to PyPI using `twine upload`
+
+**Requirements**: Make sure you have `build` and `twine` installed:
+```sh
+pip install build twine
+```
+
 ## Running Tests
 
 - (Add test instructions here if/when tests are present)

{janito-2.26.0 → janito-2.27.1}/README.md

@@ -155,7 +155,25 @@ janito -r -w "Read and update this file: ..."
 To enable all permissions (read, write, execute):
 
 ```bash
+# Using individual flags
 janito -r -w -x "Run this code: print('Hello, world!')"
+
+# Using the convenient /rwx prefix (single-shot mode)
+janito /rwx "Run this code: print('Hello, world!')"
+```
+
+#### One-Shot Mode
+For quick tasks without entering interactive mode, provide your prompt directly:
+
+```bash
+# Basic one-shot
+janito "What are the key classes in this project?"
+
+# One-shot with all permissions enabled
+janito /rwx "Create a Python script and run it"
+
+# One-shot with specific permissions
+janito -r -w "Read this file and create a summary"
 ```
 
 > **Warning:** Enabling execution tools allows running arbitrary code or shell commands. Only use `--exec` if you trust your prompt and environment.

{janito-2.26.0 → janito-2.27.1}/docs/changelogs/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.27.0] - 2025-08-16
+
+### Added
+
+- **Enhanced CLI Experience**:
+  - **One-Shot Mode Prefix Support**: Added `/rwx` prefix support to enable all tool permissions in a single command
+    - Use `/rwx "your prompt here"` to enable read, write, and execute permissions in one-shot mode
+    - Equivalent to using `-r -w -x` flags but more convenient for quick tasks
+    - Maintains security by requiring explicit user action for each command
+
+- **Enhanced Web Fetching**:
+  - **Browser-like Session Support**: Enhanced `fetch_url` tool with browser-like session capabilities
+    - Persistent session management for improved reliability
+    - Better handling of cookies and session state
+    - Enhanced user-agent and header management
+    - Improved error handling for network requests
+
+### Changed
+
+- **Improved Documentation**:
+  - Updated CLI documentation to reflect new `/rwx` prefix and one-shot mode features
+  - Enhanced fetch_url tool documentation with new session parameters
+  - Improved parameter descriptions and usage examples
+
+### Fixed
+
+- **Documentation Fixes**:
+  - Added missing docstring parameters for fetch_url tool
+  - Fixed parameter documentation inconsistencies
+
 ## [2.26.0] - 2025-08-16
 
 ### Added

janito-2.27.1/docs/changelogs/CHANGELOG_2.27.0.md

@@ -0,0 +1,64 @@
+# Changelog v2.27.0
+
+## [2.27.0] - 2025-08-16
+
+### Added
+
+- **Enhanced CLI Experience**:
+  - **One-Shot Mode Prefix Support**: Added `/rwx` prefix support to enable all tool permissions in a single command
+    - Use `/rwx "your prompt here"` to enable read, write, and execute permissions in one-shot mode
+    - Equivalent to using `-r -w -x` flags but more convenient for quick tasks
+    - Maintains security by requiring explicit user action for each command
+
+- **Enhanced Web Fetching**:
+  - **Browser-like Session Support**: Enhanced `fetch_url` tool with browser-like session capabilities
+    - Persistent session management for improved reliability
+    - Better handling of cookies and session state
+    - Enhanced user-agent and header management
+    - Improved error handling for network requests
+
+### Changed
+
+- **Improved Documentation**:
+  - Updated CLI documentation to reflect new `/rwx` prefix and one-shot mode features
+  - Enhanced fetch_url tool documentation with new session parameters
+  - Improved parameter descriptions and usage examples
+
+### Fixed
+
+- **Documentation Fixes**:
+  - Added missing docstring parameters for fetch_url tool
+  - Fixed parameter documentation inconsistencies
+
+### Developer Experience
+
+- **CLI Usability**: 
+  - Streamlined one-shot mode with convenient prefix commands
+  - Consistent behavior between interactive and non-interactive modes
+  - Clear documentation for new features
+
+### Technical Details
+
+- **Implementation**: Enhanced CLI argument parsing to support `/rwx` prefix
+- **Integration**: Full integration with existing permission system
+- **Compatibility**: Backward compatible with existing CLI flags and commands
+
+### Migration Guide
+
+For users upgrading from v2.26.0:
+
+1. **No Breaking Changes**: All existing functionality remains unchanged
+2. **New Prefix**: Use `/rwx "prompt"` for one-shot mode with all permissions
+3. **Existing Flags**: `-r -w -x` flags continue to work as before
+4. **fetch_url Tool**: Enhanced session support is automatic, no configuration needed
+
+### Contributors
+
+- Added convenient one-shot mode prefix for improved CLI experience
+- Enhanced web fetching capabilities with browser-like session support
+- Improved documentation and parameter descriptions
+- Fixed documentation inconsistencies
+
+---
+
+**Full Changelog**: https://github.com/ikignosis/janito/compare/v2.26.0...v2.27.0

{janito-2.26.0 → janito-2.27.1}/docs/guides/single-shot-terminal.md

@@ -10,6 +10,18 @@ janito "what are the key classes of this project?"
 
 Janito will process your request and exit after displaying the result.
 
+### Quick Permission Setup
+
+For one-shot mode, you can quickly enable all tool permissions using the `/rwx` prefix:
+
+```bash
+# Enable read, write, and execute permissions
+janito /rwx "create a python script and run it"
+
+# Or use individual flags
+janito -r -w -x "create a python script and run it"
+```
+
 > ⚠️ **Warning:** Some models may not complete all required steps in a single-shot (one-off) run. If the model does not act as expected, try appending "; just do it" to your command-line prompt to encourage direct action.
 
 ![One-Shot Terminal Shell](../imgs/terminal-one-shot.png)

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.