janito 2.27.0__tar.gz → 2.28.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.27.0
+Version: 2.28.0
 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.0 → janito-2.28.0}/docs/changelogs/CHANGELOG.md

@@ -311,12 +311,12 @@ For users upgrading from previous versions:
 
 ## [2.9.0] - 2025-07-16
 ### Added
-- Added new `kimi-k2-turbo-preview` model to MoonshotAI provider
+- Added new `kimi-k2-turbo-preview` model to Moonshot provider
 - Added visual indicators for default models in provider registry with star icons
 
 ### Changed
-- Updated default MoonshotAI model from `kimi-k2-0711-preview` to `kimi-k2-turbo-preview`
-- Updated all documentation to reflect new MoonshotAI model names and recommendations
+- Updated default Moonshot model from `kimi-k2-0711-preview` to `kimi-k2-turbo-preview`
+- Updated all documentation to reflect new Moonshot model names and recommendations
 - Updated project URLs, author email, and documentation for migration to ikignosis organization
 - Updated repository links in documentation and configuration files to point to ikignosis GitHub organization
 - Changed maintainer email in provider modules to janito@ikignosis.org
@@ -344,7 +344,7 @@ For users upgrading from previous versions:
 - **Provider-specific settings**: Simplified configuration system.
 
 ### Documentation
-- Updated MoonshotAI setup guide with platform.moonshot.ai domain.
+- Updated Moonshot setup guide with platform.moonshot.ai domain.
 - Improved CLI usage documentation and fixed syntax highlighting.
 - Removed broken references to model_info.py files in supported-providers-models.md.
 - Added comprehensive documentation updates across the project.

{janito-2.27.0 → janito-2.28.0}/docs/index.md

@@ -17,7 +17,7 @@ Janito is a powerful AI assistant designed for developers, providing intelligent
 - **Terminal Integration**: Seamless shell integration with intelligent command assistance
 - **Code Intelligence**: Advanced code analysis and generation capabilities
 - **Extensible Tools**: Custom tool development and integration
-- **Multi-Provider Support**: Works with OpenAI, DeepSeek, MoonshotAI, and more
+- **Multi-Provider Support**: Works with OpenAI, DeepSeek, Moonshot, and more
 - **Human-Guided AI**: Collaborative AI that works with you, not instead of you
 
 ## Documentation Sections
@@ -47,7 +47,7 @@ Janito supports multiple AI providers:
 
 - [OpenAI](openai-setup.md)
 - [DeepSeek](deepseek-setup.md)
-- [MoonshotAI](moonshotai-setup.md)
+- [Moonshot](moonshot-setup.md)
 - [Mistral](mistral-setup.md)
 - [Z.ai](z-ai-setup.md)
 - [Cerebras](cerebras-setup.md)

janito-2.27.0/docs/moonshotai-setup.md → janito-2.28.0/docs/moonshot-setup.md

@@ -1,39 +1,39 @@
-# Configuring Janito for MoonshotAI
+# Configuring Janito for Moonshot
 
-Janito supports MoonshotAI as an LLM provider. This guide explains how to configure Janito to use MoonshotAI models.
+Janito supports Moonshot as an LLM provider. This guide explains how to configure Janito to use Moonshot models.
 
-## 1. Obtain a MoonshotAI API Key
+## 1. Obtain a Moonshot API Key
 
 - Sign up or log in at [Moonshot AI Platform](https://platform.moonshot.ai) to get your API key.
 - Navigate to the API Keys section in your dashboard to create and manage your keys.
 
-## 2. Set Your MoonshotAI API Key in Janito
+## 2. Set Your Moonshot API Key in Janito
 
-You must specify both the API key and the provider name when configuring Janito for MoonshotAI:
+You must specify both the API key and the provider name when configuring Janito for Moonshot:
 
 ```bash
-janito --set-api-key YOUR_MOONSHOT_API_KEY -p moonshotai
+janito --set-api-key YOUR_MOONSHOT_API_KEY -p moonshot
 ```
 
-Replace `YOUR_MOONSHOT_API_KEY` with your actual MoonshotAI API key.
+Replace `YOUR_MOONSHOT_API_KEY` with your actual Moonshot API key.
 
-## 3. Select MoonshotAI as the Provider
+## 3. Select Moonshot as the Provider
 
-You can set MoonshotAI as your default provider:
+You can set Moonshot as your default provider:
 
 ```bash
-janito --set provider=moonshotai
+janito --set provider=moonshot
 ```
 
 Or specify it per command:
 
 ```bash
-janito -p moonshotai "Your prompt here"
+janito -p moonshot "Your prompt here"
 ```
 
-## 4. Choose a MoonshotAI Model
+## 4. Choose a Moonshot Model
 
-Janito supports the following MoonshotAI models:
+Janito supports the following Moonshot models:
 
 - `kimi-k2-turbo-preview` (default) - Advanced reasoning model with 128k context window
 - `kimi-k2-turbo-preview` - Turbo version of the advanced reasoning model with 128k context window
@@ -44,7 +44,7 @@ Janito supports the following MoonshotAI models:
 To select a model:
 
 ```bash
-janito -p moonshotai -m kimi-k1-32k "Your prompt here"
+janito -p moonshot -m kimi-k1-32k "Your prompt here"
 ```
 
 ## 5. Verify Your Configuration
@@ -57,7 +57,7 @@ janito --show-config
 
 ## 6. API Endpoint Information
 
-MoonshotAI uses an OpenAI-compatible API endpoint:
+Moonshot uses an OpenAI-compatible API endpoint:
 
 - **Base URL**: `https://api.moonshot.ai/v1`
 - **Authentication**: Bearer token (API key)
@@ -66,7 +66,7 @@ MoonshotAI uses an OpenAI-compatible API endpoint:
 ## 7. Troubleshooting
 
 - Ensure your API key is correct and has sufficient credits.
-- If you encounter issues, use `janito --list-providers` to verify MoonshotAI is available.
+- If you encounter issues, use `janito --list-providers` to verify Moonshot is available.
 - Check your API key permissions and rate limits in the Moonshot AI Platform dashboard.
 - For more help, see the main [Configuration Guide](guides/configuration.md) or run `janito --help`.
 

janito-2.28.0/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.28.0/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.28.0/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.28.0/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.28.0/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.