janito 3.12.1__tar.gz → 3.12.2__tar.gz

{janito-3.12.1 → janito-3.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.12.1
+Version: 3.12.2
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

janito-3.12.2/alibaba-qwen3.md

@@ -0,0 +1,81 @@
+# Alibaba Cloud Qwen Models Overview
+
+## Flagship Models (Singapore Region)
+
+| Model        | Description                                    | Max Context Window | Input Price (per million tokens) | Output Price (per million tokens) |
+|--------------|------------------------------------------------|--------------------|----------------------------------|-----------------------------------|
+| Qwen-Max     | Ideal for complex tasks, most powerful         | 32,768             | $1.6                             | $6.4                              |
+| Qwen-Plus    | Balanced performance, speed, and cost          | 1,000,000          | $0.4                             | $1.2                              |
+| Qwen-Flash   | Ideal for simple tasks, fast and low-cost      | 1,000,000          | $0.05                            | $0.4                              |
+| Qwen-Coder   | Excellent code model, excels at tool calling   | 1,000,000          | $0.3                             | $1.5                              |
+
+## Model Categories
+
+### Text Generation - Qwen
+Commercial models:
+- QwQ
+- Qwen-Max
+- Qwen-Plus
+- Qwen-Flash
+
+Open-source models:
+- Qwen3
+- Qwen2.5
+
+Multimodal models:
+- Qwen-VL (visual understanding)
+- QVQ (visual reasoning)
+- Qwen-Omni (omni-modal)
+- Qwen-Omni-Realtime (real-time multimodal)
+
+Domain-specific models:
+- Code model
+- Translation model
+- Role-play model
+
+### Image Generation - Qwen
+- Qwen-Image: Text-to-image, excels at rendering complex text (Chinese/English)
+- Qwen-Image-Edit: Image and text editing operations (style transfer, text modification, object editing)
+- Wan: Generates exquisite images from a single sentence
+
+### Video Generation
+- Text-to-video: Generates videos from a single sentence
+- Image-to-video:
+  - First-frame-to-video
+  - First-and-last-frame-to-video
+  - Multi-image-to-video
+
+### Video Editing
+- General-purpose video editing: Performs various video editing tasks based on text, images, and videos
+
+### Embedding
+- Text embedding: Converts text into numbers for search, clustering, recommendation, and classification tasks
+
+## Qwen-Max Details
+
+### Qwen3-Max (Preview)
+- Context window: 262,144 tokens
+- Maximum input: 258,048 tokens
+- Maximum output: 65,536 tokens
+- Input pricing (tiered):
+  - 0-32K tokens: $1.2 per million tokens
+  - 32K-128K tokens: $2.4 per million tokens
+  - 128K-252K tokens: $3 per million tokens
+- Output price: $6 per million tokens
+- Free quota: 1 million tokens (validity: 90 days after activating Alibaba Cloud Model Studio)
+- Supports context cache
+
+### Qwen-Max (Stable/Latest)
+- Context window: 32,768 tokens
+- Maximum input: 30,720 tokens
+- Maximum output: 8,192 tokens
+- Input price: $1.6 per million tokens
+- Output price: $6.4 per million tokens
+- 50% discount for batch calling
+- Free quota: 1 million tokens each for input and output (validity: 90 days after activating Alibaba Cloud Model Studio)
+
+### Qwen-Max Snapshots
+- qwen-max-2025-01-25 (also known as qwen-max-0125, Qwen2.5-Max)
+
+## Qwen-Plus
+This model provides balanced capabilities between Qwen-Max and Qwen-Flash, making it ideal for moderately complex tasks.

janito-3.12.2/cow.txt

@@ -0,0 +1,7 @@
+
+         (__)
+         (oo)
+  /-------\/
+ / |     ||
+*  ||----||
+   ^^    ^^

janito-3.12.2/detailed_cow.txt

@@ -0,0 +1,12 @@
+
+                 (__)
+                 (oo)
+          /-------\/
+         / |     ||
+        *  ||----||
+           ^^    ^^
+    \   ^__^
+     \  (oo)\_______
+        (__)\       )\/\
+            ||----w |
+            ||     ||

{janito-3.12.1 → janito-3.12.2}/docs/index.md

@@ -32,7 +32,7 @@ Learn how to use Janito effectively:
 - [Profiles](guides/profiles.md) - Custom configurations for different workflows
 - [Stock Market Guide](guides/stock-market-guide.md) - Accessing financial market data
 - [Market Data Sources](guides/market-data-sources.md) - Reliable sources for financial data
-- [Read Chart Examples](guides/read-chart-examples.md) - Data visualization in the terminal
+
 
 ### Development & Extension
 

{janito-3.12.1 → janito-3.12.2}/docs/plugins/README.md

@@ -1,102 +1,102 @@
-# Janito Plugin System Documentation
-
-This directory contains comprehensive documentation for the Janito plugin system, consolidated from multiple sources for easier access.
-
-## Quick Navigation
-
-- **[Plugin Development Guide](plugin-development.md)** - Complete guide for creating plugins
-- **[Remote Plugins](remote-plugins.md)** - Using plugins from remote repositories
-- **[Built-in Plugins](../built-in-plugins.md)** - Documentation for included plugins
-- **[API Reference](api-reference.md)** - Technical details and interfaces
-- **[Examples](examples/)** - Working plugin examples
-
-## Overview
-
-The Janito plugin system allows you to extend functionality with custom tools, commands, and features. Plugins can be:
-
-- **Local plugins** - Stored in `./plugins/` or `~/.janito/plugins/`
-- **Remote plugins** - Loaded from the `ikignosis/janito-plugins` repository
-- **Built-in plugins** - Included with janito-coder
-
-## Quick Start
-
-### Creating a Basic Plugin
-
-```python
-from janito.plugins.base import Plugin, PluginMetadata
-from janito.tools.tool_base import ToolBase, ToolPermissions
-
-class HelloTool(ToolBase):
-    tool_name = "hello"
-    permissions = ToolPermissions(read=True, write=False, execute=True)
-    
-    def run(self, name="World"):
-        return f"Hello, {name}!"
-
-class HelloPlugin(Plugin):
-    def get_metadata(self):
-        return PluginMetadata(
-            name="hello",
-            version="1.0.0",
-            description="A simple greeting plugin",
-            author="You"
-        )
-    
-    def get_tools(self):
-        return [HelloTool]
-```
-
-### Enabling Plugins
-
-Add to `janito.json`:
-
-```json
-{
-  "plugins": {
-    "load": {
-      "hello": true
-    }
-  }
-}
-```
-
-## Available Documentation
-
-### Core Documentation
-- [Plugin Development Guide](plugin-development.md) - Step-by-step plugin creation
-- [Remote Plugins](remote-plugins.md) - Using community plugins
-- [Configuration](configuration.md) - Plugin configuration options
-
-### Built-in Plugins
-- [Git Analyzer](../built-in-plugins/git-analyzer.md) - Git repository analysis
-- [Code Navigator](../built-in-plugins/code-navigator.md) - Code navigation tools
-- [Example Plugin](../built-in-plugins/example.md) - Basic plugin example
-
-### Advanced Topics
-- [Plugin Architecture](architecture.md) - System design and internals
-- [Testing Plugins](testing.md) - Writing tests for plugins
-- [Publishing Plugins](publishing.md) - Sharing plugins with the community
-
-## Getting Help
-
-- **Issues**: Report problems on GitHub
-- **Discussions**: Join community forums
-- **Examples**: Check the `examples/` directory for working samples
-
-## Directory Structure
-
-```
-docs/plugins/
-├── README.md                    # This file
-├── plugin-development.md        # Complete development guide
-├── remote-plugins.md           # Remote repository usage
-├── built-in-plugins/           # Built-in plugin docs
-│   ├── git-analyzer.md
-│   ├── code-navigator.md
-│   └── example.md
-├── examples/                   # Sample plugins
-│   ├── basic/
-│   ├── intermediate/
-│   └── advanced/
-└── api-reference.md          # Technical reference
+# Janito Plugin System Documentation
+
+This directory contains comprehensive documentation for the Janito plugin system, consolidated from multiple sources for easier access.
+
+## Quick Navigation
+
+- **[Plugin Development Guide](plugin-development.md)** - Complete guide for creating plugins
+- **[Remote Plugins](remote-plugins.md)** - Using plugins from remote repositories
+- **[Built-in Plugins](../built-in-plugins.md)** - Documentation for included plugins
+- **[API Reference](api-reference.md)** - Technical details and interfaces
+- **[Examples](examples/)** - Working plugin examples
+
+## Overview
+
+The Janito plugin system allows you to extend functionality with custom tools, commands, and features. Plugins can be:
+
+- **Local plugins** - Stored in `./plugins/` or `~/.janito/plugins/`
+- **Remote plugins** - Loaded from the `ikignosis/janito-plugins` repository
+- **Built-in plugins** - Included with janito
+
+## Quick Start
+
+### Creating a Basic Plugin
+
+```python
+from janito.plugins.base import Plugin, PluginMetadata
+from janito.tools.tool_base import ToolBase, ToolPermissions
+
+class HelloTool(ToolBase):
+    tool_name = "hello"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+    
+    def run(self, name="World"):
+        return f"Hello, {name}!"
+
+class HelloPlugin(Plugin):
+    def get_metadata(self):
+        return PluginMetadata(
+            name="hello",
+            version="1.0.0",
+            description="A simple greeting plugin",
+            author="You"
+        )
+    
+    def get_tools(self):
+        return [HelloTool]
+```
+
+### Enabling Plugins
+
+Add to `janito.json`:
+
+```json
+{
+  "plugins": {
+    "load": {
+      "hello": true
+    }
+  }
+}
+```
+
+## Available Documentation
+
+### Core Documentation
+- [Plugin Development Guide](plugin-development.md) - Step-by-step plugin creation
+- [Remote Plugins](remote-plugins.md) - Using community plugins
+- [Configuration](configuration.md) - Plugin configuration options
+
+### Built-in Plugins
+- [Git Analyzer](../built-in-plugins/git-analyzer.md) - Git repository analysis
+- [Code Navigator](../built-in-plugins/code-navigator.md) - Code navigation tools
+- [Example Plugin](../built-in-plugins/example.md) - Basic plugin example
+
+### Advanced Topics
+- [Plugin Architecture](architecture.md) - System design and internals
+- [Testing Plugins](testing.md) - Writing tests for plugins
+- [Publishing Plugins](publishing.md) - Sharing plugins with the community
+
+## Getting Help
+
+- **Issues**: Report problems on GitHub
+- **Discussions**: Join community forums
+- **Examples**: Check the `examples/` directory for working samples
+
+## Directory Structure
+
+```
+docs/plugins/
+├── README.md                    # This file
+├── plugin-development.md        # Complete development guide
+├── remote-plugins.md           # Remote repository usage
+├── built-in-plugins/           # Built-in plugin docs
+│   ├── git-analyzer.md
+│   ├── code-navigator.md
+│   └── example.md
+├── examples/                   # Sample plugins
+│   ├── basic/
+│   ├── intermediate/
+│   └── advanced/
+└── api-reference.md          # Technical reference
 ```

{janito-3.12.1 → janito-3.12.2}/docs/plugins/architecture.md

@@ -1,128 +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/plugins/tools/local/`. This separation ensures that the core functionality remains stable while the plugin interfaces can be organized and extended.
-
-```
-janito/plugins/tools/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
-
+# 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/plugins/tools/local/`. This separation ensures that the core functionality remains stable while the plugin interfaces can be organized and extended.
+
+```
+janito/plugins/tools/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
+
+└── 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-3.12.2/docs/plugins/built-in-plugins/visualization.md

@@ -0,0 +1,62 @@
+# Visualization Plugin
+
+## Overview
+
+The Visualization plugin provides data visualization and charting capabilities. This plugin enables the display of data in various visual formats, making it easier to understand and analyze information.
+
+## Resources Provided
+
+### Tools
+
+| Tool Name | Function | Description |
+|-----------|----------|-------------|
+
+| `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
+
+### Displaying an Image
+```json
+{
+  "tool": "show_image",
+  "path": "chart.png",
+  "width": 80,
+  "preserve_aspect": true
+}
+```
+
+### Creating an Image Grid
+```json
+{
+  "tool": "show_image_grid",
+  "paths": ["image1.png", "image2.png", "image3.png"],
+  "columns": 2,
+  "width": 40
+}
+```
+
+
+
+
+## Configuration
+
+This plugin does not require any specific configuration. Image display uses default dimensions and styling.
+
+
+## Security Considerations
+
+- Images are displayed client-side with no external dependencies
+- No data is transmitted to external services
+- Large images are resized to prevent performance issues
+
+## Integration
+
+The Visualization plugin provides image display capabilities for:
+
+- Visual content presentation
+- Multi-image comparisons
+- Documentation with visual elements
+- Terminal-based image viewing
+
+This enables rich visual presentation capabilities within the terminal interface.

{janito-3.12.1 → janito-3.12.2}/docs/tools-index.md

@@ -39,15 +39,7 @@ Returns:
 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.
-
-**Arguments:**
-
-- `data` (dict): Chart data in JSON format. Should contain 'type' (bar, line, pie, table) and 'data' keys.
-- `title` (str, optional): Chart title. Defaults to "Chart".
-- `width` (int, optional): Chart width. Defaults to 80.
 - `height` (int, optional): Chart height. Defaults to 20.
 
 **Returns:**
@@ -56,9 +48,7 @@ Display charts and data visualizations in the terminal using rich.
 
 **Example Usage:**
 
-- Display a table: `read_chart(data={"type": "table", "data": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}, title="Users")`
-- Display a bar chart: `read_chart(data={"type": "bar", "data": {"Q1": 100, "Q2": 150}}, title="Sales")`
-- Display a pie chart: `read_chart(data={"type": "pie", "data": {"Desktop": 45, "Mobile": 30}}, title="Usage")`
+
 
 ### Web Tools