janito 3.0.0__tar.gz → 3.2.0__tar.gz

janito-3.2.0/ANNOUNCEMENT_v3.1.0.md

@@ -0,0 +1,63 @@
+# 🚀 Janito v3.1.0 Released - Enter Key Cancellation for Chat Mode
+
+**Release Date:** August 23, 2025  
+**Version:** v3.1.0  
+**PyPI:** [janito 3.1.0](https://pypi.org/project/janito/3.1.0/)
+
+## 🎯 What's New
+
+### Instant Request Cancellation in Chat Mode
+
+Say goodbye to waiting for stuck LLM requests! Janito v3.1.0 introduces **Enter key cancellation support** for interactive chat mode.
+
+#### ✨ Key Features
+- **Press Enter to Cancel**: Instantly cancel any running request with a single key press
+- **Real-time Feedback**: Clear visual confirmation when cancellation occurs
+- **Clean Recovery**: Session remains active and ready for your next prompt
+- **Cross-Platform**: Works seamlessly across all supported platforms
+
+#### 🎮 How to Use
+1. Start chat mode: `janito`
+2. Submit any prompt
+3. **Press Enter** at any time to cancel the current request
+4. See immediate confirmation: "Request cancelled by Enter key"
+5. Continue chatting without interruption
+
+## 📦 Installation & Upgrade
+
+```bash
+# New installation
+pip install janito==3.1.0
+
+# Upgrade existing installation
+pip install --upgrade janito
+```
+
+## 🔧 Technical Highlights
+
+- **Global Cancellation Manager**: Robust cross-component cancellation system
+- **Thread-Safe**: Safe cancellation across async operations
+- **Backward Compatible**: All existing functionality preserved
+- **Clean Architecture**: Extensible design for future enhancements
+
+## 📚 Documentation
+
+- [Full Release Notes](docs/changelogs/CHANGELOG_3.1.0.md)
+- [Updated Usage Guide](docs/guides/using.md)
+- [CLI Options Reference](docs/reference/cli-options.md)
+
+## 🌟 Try It Now
+
+Experience the improved chat mode with instant cancellation:
+
+```bash
+janito
+# Then try: "Write a comprehensive analysis of quantum computing applications"
+# Press Enter anytime to cancel if needed!
+```
+
+---
+
+**Happy coding!** 🎉
+
+*Join our community for support and discussions.*

{janito-3.0.0 → janito-3.2.0}/PKG-INFO

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

@@ -517,4 +517,37 @@ For users upgrading from previous versions:
 
 ---
 
+## [3.1.0] - 2025-08-23
+
+### Added
+
+- **Enter Key Cancellation Support for Chat Mode**: Revolutionary usability improvement for interactive chat sessions
+  - **Instant Request Cancellation**: Press **Enter key** at any time to immediately cancel current LLM operations
+  - **Global Cancellation Manager**: Robust cross-component cancellation system spanning agent, driver, and prompt handler
+  - **User Feedback**: Clear visual confirmation with red "Request cancelled by Enter key" message
+  - **Clean State Management**: Automatic cleanup of cancellation state after request completion
+  - **Thread-Safe Implementation**: Safe cancellation across multiple threads and async operations
+
+### Technical Implementation
+
+- **Global Cancellation Manager**: New `janito.llm.cancellation_manager` module provides centralized cancellation handling
+- **Key Binding Integration**: Enhanced chat mode with dedicated Enter key handling for cancellation
+- **Cross-Component Support**: Cancellation signals properly propagate through entire application stack
+- **Backward Compatible**: All existing functionality preserved, cancellation is additive feature
+
+### Developer Experience
+
+- **Extensible Architecture**: Cancellation system designed for future integration with other components
+- **Clean API**: Simple interface for starting, cancelling, and clearing requests across application
+- **Comprehensive Testing**: Full test coverage for cancellation scenarios and edge cases
+
+### Documentation
+
+- Updated CLI options documentation with new cancellation behavior
+- Enhanced chat mode guides with cancellation instructions
+- Added troubleshooting section for long-running requests
+- New dedicated changelog: [CHANGELOG_3.1.0.md](../changelogs/CHANGELOG_3.1.0.md)
+
+---
+
 **Full Changelog**: https://github.com/ikignosis/janito/compare/v2.22.0...v2.23.0

janito-3.2.0/docs/changelogs/CHANGELOG_3.1.0.md

@@ -0,0 +1,51 @@
+# Janito v3.1.0 Release Notes
+
+**Release Date:** August 23, 2025  
+**Version:** v3.1.0  
+**PyPI:** [janito 3.1.0](https://pypi.org/project/janito/3.1.0/)
+
+## 🚀 New Features
+
+### Enter Key Cancellation Support for Chat Mode
+
+This release introduces a significant usability improvement for the interactive chat mode: **Enter key cancellation support**.
+
+#### What's New
+- **Instant Request Cancellation**: Press the **Enter key** at any time during a request to immediately cancel the current LLM operation
+- **Global Cancellation Manager**: Robust cancellation system that works across all components (agent, driver, prompt handler)
+- **User Feedback**: Clear visual confirmation when a request is cancelled
+- **Clean State Management**: Proper cleanup of cancellation state after request completion
+
+#### How It Works
+When you're in chat mode and a request is taking longer than expected:
+1. Simply press **Enter** - no need for Ctrl+C or other interrupt combinations
+2. The current LLM request is immediately cancelled
+3. You'll see a red confirmation message: "Request cancelled by Enter key"
+4. The chat session remains active and ready for your next prompt
+
+#### Technical Implementation
+- **Global Cancellation Manager**: New `janito.llm.cancellation_manager` module provides centralized cancellation handling
+- **Key Binding Integration**: Chat mode now has dedicated Enter key handling for cancellation
+- **Cross-Component Support**: Cancellation signals propagate properly through agent, driver, and prompt handler layers
+- **Thread-Safe**: Robust handling across multiple threads and async operations
+
+## 🔄 Changes
+
+- Enhanced chat mode user experience with intuitive cancellation
+- Improved responsiveness during long-running LLM requests
+- Better error handling and state cleanup for cancelled operations
+
+## 📚 Documentation Updates
+
+- Updated CLI options documentation
+- Added cancellation behavior to chat mode guides
+- Enhanced troubleshooting sections for long-running requests
+
+## 🛠️ Developer Notes
+
+The cancellation system is designed to be extensible and can be integrated with other components as needed. The global cancellation manager provides a clean API for starting, cancelling, and clearing requests across the entire application stack.
+
+---
+
+**Installation:** `pip install janito==3.1.0`  
+**Upgrade:** `pip install --upgrade janito`

{janito-3.0.0 → janito-3.2.0}/docs/guides/using.md

@@ -24,6 +24,7 @@ janito --web
 ## Basic Usage Tips
 - Use natural language to describe what you want Janito to do (e.g., "Add type hints to all functions in utils.py").
 - In the chat shell, use `/help` for available commands. Use `/exec on` to enable code/shell execution tools at runtime.
+- **Press Enter** at any time to cancel a long-running request in chat mode
 - Use CLI flags to customize behavior (see [CLI Options](../reference/cli-options.md)).
 
 ## More Resources

{janito-3.0.0 → janito-3.2.0}/docs/plugins/built-in-plugins/filemanager.md

@@ -74,7 +74,7 @@ Overwrite existing file (use with caution):
 - **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)
+- **Loop Protection**: Prevents repeated create calls for the same path within a short window (1 allowed per 10 seconds)
 
 **Return Values:**
 

janito-3.2.0/docs/together-setup.md

@@ -0,0 +1,86 @@
+# Together AI Setup Guide
+
+This guide explains how to set up the Together AI provider for Janito, giving you access to OLMo 2 models and other open-source models.
+
+## 1. Get Your Together AI API Key
+
+1. Visit [Together AI](https://api.together.xyz/)
+2. Sign up for an account
+3. Navigate to your API keys section
+4. Copy your API key
+
+## 2. Configure Janito for Together AI
+
+### Set your API key:
+```bash
+janito --set-api-key YOUR_TOGETHER_API_KEY --provider together
+```
+
+### Set Together AI as your default provider:
+```bash
+janito --set-config provider together
+```
+
+## 3. Available Models
+
+The Together AI provider supports several models including:
+
+- **allenai/OLMo-2-0325-32B-Instruct** (default) - Fully open 32B parameter model
+- **allenai/OLMo-2-1124-7B-Instruct** - 7B parameter OLMo 2 model
+- **allenai/OLMo-2-0425-1B** - 1B parameter OLMo 2 model
+- **meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo**
+- **meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo**
+- **mistralai/Mixtral-8x7B-Instruct-v0.1**
+- **deepseek-ai/deepseek-llm-67b-chat**
+
+## 4. Usage Examples
+
+### Basic chat:
+```bash
+janito chat --provider together
+```
+
+### Use a specific model:
+```bash
+janito chat --provider together --model allenai/OLMo-2-1124-7B-Instruct
+```
+
+### Single query:
+```bash
+janito "Explain quantum computing" --provider together
+```
+
+### Use OLMo 2 1B for faster responses:
+```bash
+janito "Write a Python function" --provider together --model allenai/OLMo-2-0425-1B
+```
+
+## 5. Environment Variables
+
+The Together AI provider uses the following environment variable:
+- `TOGETHER_API_KEY` - Your Together AI API key
+
+## 6. Troubleshooting
+
+### Check if Together AI is available:
+```bash
+janito --list-providers
+```
+
+### Verify your API key:
+```bash
+janito ping-providers
+```
+
+### List available models:
+```bash
+janito list-models --provider together
+```
+
+## 7. Pricing
+
+Together AI offers pay-as-you-go pricing. Check their [pricing page](https://api.together.xyz/pricing) for current rates.
+
+## 8. Regional Availability
+
+Together AI is available globally, including Europe and China, with no regional restrictions.

{janito-3.0.0 → janito-3.2.0}/janito/README.md

@@ -106,6 +106,9 @@ janito --set model=kimi-k1-8k
 
 ## Advanced Features
 
+### 🚀 New in v3.1.0: Enter Key Cancellation
+**Chat Mode Enhancement**: Press **Enter** at any time to instantly cancel long-running requests in interactive chat mode. No more waiting for stuck requests!
+
 ### Tool Usage
 
 Janito includes powerful built-in tools for:

janito-3.2.0/janito/cli/chat_mode/bindings.py

@@ -0,0 +1,64 @@
+"""
+Key bindings for Janito Chat CLI.
+"""
+
+from prompt_toolkit.key_binding import KeyBindings
+from janito.tools.permissions import get_global_allowed_permissions
+
+
+class KeyBindingsFactory:
+    @staticmethod
+    def create():
+        bindings = KeyBindings()
+
+        @bindings.add("c-y")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Yes"
+            buf.validate_and_handle()
+
+        @bindings.add("c-n")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "No"
+            buf.validate_and_handle()
+
+        @bindings.add("f2")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "/restart"
+            buf.validate_and_handle()
+
+        @bindings.add("f12")
+        def _(event):
+            buf = event.app.current_buffer
+            buf.text = "Do It"
+            buf.validate_and_handle()
+
+        @bindings.add("c-c")
+        def _(event):
+            """Handle Ctrl+C to interrupt current request or exit chat."""
+            # Use global cancellation manager for robust cancellation
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+
+            cancelled = cancel_manager.cancel_current_request()
+            if cancelled:
+                # Provide user feedback
+                from rich.console import Console
+
+                console = Console()
+                console.print("[red]Request cancelled by Ctrl+C[/red]")
+
+                # Prevent the Ctrl+C from being processed as input
+                event.app.output.flush()
+                return
+            else:
+                # No active request to cancel, exit the chat
+                from rich.console import Console
+                console = Console()
+                console.print("[yellow]Goodbye![/yellow]")
+                event.app.exit()
+
+        return bindings

{janito-3.0.0 → janito-3.2.0}/janito/cli/chat_mode/session.py

@@ -22,6 +22,7 @@ import time
 
 # Shared prompt/agent factory
 from janito.cli.prompt_setup import setup_agent_and_prompt_handler
+from janito.llm.cancellation_manager import get_cancellation_manager
 
 import time
 
@@ -113,6 +114,10 @@ class ChatSession:
 
         # Check if multi-line mode should be enabled by default
         self.multi_line_mode = getattr(args, "multi", False) if args else False
+        
+        # Default to single-line mode (Enter submits) unless explicitly enabled
+        if not self.multi_line_mode:
+            self.multi_line_mode = False
 
     def _select_profile_and_role(self, args, role):
         profile, role_arg, python_profile, market_profile = self._extract_args(args)
@@ -283,7 +288,13 @@ class ChatSession:
                 )
             )
 
-            self._prompt_handler.run_prompt(cmd_input)
+            try:
+                self._prompt_handler.run_prompt(cmd_input)
+            finally:
+                # Ensure cancellation manager is cleared
+                cancel_manager = get_cancellation_manager()
+                cancel_manager.clear_current_request()
+
             end_time = time.time()
             elapsed = end_time - start_time
             self.msg_count += 1

{janito-3.0.0 → janito-3.2.0}/janito/cli/chat_mode/shell/commands/security/allowed_sites.py

@@ -59,39 +59,53 @@ Examples:
         command = args[0].lower()
         whitelist_manager = get_url_whitelist_manager()
 
-        if command == "list":
-            sites = whitelist_manager.get_allowed_sites()
-            if sites:
-                print("Allowed sites:")
-                for site in sites:
-                    print(f"  • {site}")
-            else:
-                print("No sites are whitelisted (all sites are allowed)")
-
-        elif command == "add":
-            if len(args) < 2:
-                print("Error: Please specify a site to add")
-                return
-            site = args[1]
-            if whitelist_manager.add_allowed_site(site):
-                print(f"✅ Added '{site}' to allowed sites")
-            else:
-                print(f"ℹ️ '{site}' is already in allowed sites")
-
-        elif command == "remove":
-            if len(args) < 2:
-                print("Error: Please specify a site to remove")
-                return
-            site = args[1]
-            if whitelist_manager.remove_allowed_site(site):
-                print(f"✅ Removed '{site}' from allowed sites")
-            else:
-                print(f"ℹ️ '{site}' was not in allowed sites")
-
-        elif command == "clear":
-            whitelist_manager.clear_whitelist()
-            print("✅ Cleared all allowed sites (all sites are now allowed)")
-
+        handlers = {
+            "list": self._handle_list,
+            "add": self._handle_add,
+            "remove": self._handle_remove,
+            "clear": self._handle_clear,
+        }
+
+        handler = handlers.get(command)
+        if handler:
+            handler(args, whitelist_manager)
         else:
             print(f"Error: Unknown command '{command}'")
             print(self.get_usage())
+
+    def _handle_list(self, args, whitelist_manager):
+        """Handle list command."""
+        sites = whitelist_manager.get_allowed_sites()
+        if sites:
+            print("Allowed sites:")
+            for site in sites:
+                print(f"  • {site}")
+        else:
+            print("No sites are whitelisted (all sites are allowed)")
+
+    def _handle_add(self, args, whitelist_manager):
+        """Handle add command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to add")
+            return
+        site = args[1]
+        if whitelist_manager.add_allowed_site(site):
+            print(f"✅ Added '{site}' to allowed sites")
+        else:
+            print(f"ℹ️ '{site}' is already in allowed sites")
+
+    def _handle_remove(self, args, whitelist_manager):
+        """Handle remove command."""
+        if len(args) < 2:
+            print("Error: Please specify a site to remove")
+            return
+        site = args[1]
+        if whitelist_manager.remove_allowed_site(site):
+            print(f"✅ Removed '{site}' from allowed sites")
+        else:
+            print(f"ℹ️ '{site}' was not in allowed sites")
+
+    def _handle_clear(self, args, whitelist_manager):
+        """Handle clear command."""
+        whitelist_manager.clear_whitelist()
+        print("✅ Cleared all allowed sites (all sites are now allowed)")

janito-3.2.0/janito/cli/core/model_guesser.py

@@ -0,0 +1,70 @@
+"""
+Module for guessing the provider based on model names.
+"""
+
+from janito.providers.registry import LLMProviderRegistry
+
+
+def guess_provider_from_model(model_name: str) -> str:
+    """
+    Guess the provider based on the model name.
+
+    Args:
+        model_name: The name of the model to guess the provider for
+
+    Returns:
+        The provider name if a match is found, None otherwise
+    """
+    if not model_name:
+        return None
+
+    model_name = model_name.lower()
+
+    # Check each provider's models
+    return _find_provider_for_model(model_name)
+
+
+def _find_provider_for_model(model_name: str) -> str:
+    """Find provider for given model name."""
+    for provider_name in LLMProviderRegistry.list_providers():
+        provider_class = LLMProviderRegistry.get(provider_name)
+        if not provider_class:
+            continue
+
+        if _check_provider_models(provider_name, provider_class, model_name):
+            return provider_name
+
+    return None
+
+
+def _check_provider_models(provider_name: str, provider_class, model_name: str) -> bool:
+    """Check if provider has matching model."""
+    try:
+        if hasattr(provider_class, "MODEL_SPECS"):
+            model_specs = provider_class.MODEL_SPECS
+            for spec_model_name in model_specs.keys():
+                if spec_model_name.lower() == model_name:
+                    return True
+
+        # Handle special cases like moonshot
+        if provider_name == "moonshot":
+            return _check_moonshot_models(model_name)
+
+    except Exception:
+        # Skip providers that have issues accessing model specs
+        pass
+
+    return False
+
+
+def _check_moonshot_models(model_name: str) -> bool:
+    """Check moonshot models specifically."""
+    try:
+        from janito.providers.moonshot.model_info import MOONSHOT_MODEL_SPECS
+
+        for spec_model_name in MOONSHOT_MODEL_SPECS.keys():
+            if spec_model_name.lower() == model_name:
+                return True
+    except ImportError:
+        pass
+    return False

{janito-3.0.0 → janito-3.2.0}/janito/cli/prompt_core.py

@@ -207,15 +207,26 @@ class PromptHandler:
         """
         try:
             self._print_verbose_debug("Calling agent.chat()...")
-            final_event = self.agent.chat(prompt=user_prompt)
-            if hasattr(self.agent, "set_latest_event"):
-                self.agent.set_latest_event(final_event)
-            self.agent.last_event = final_event
-            self._print_verbose_debug(f"agent.chat() returned: {final_event}")
-            self._print_verbose_final_event(final_event)
-            if on_event and final_event is not None:
-                on_event(final_event)
-                global_event_bus.publish(final_event)
+
+            # Use global cancellation manager
+            from janito.llm.cancellation_manager import get_cancellation_manager
+
+            cancel_manager = get_cancellation_manager()
+            driver_cancel_event = cancel_manager.start_new_request()
+
+            try:
+                final_event = self.agent.chat(prompt=user_prompt)
+                if hasattr(self.agent, "set_latest_event"):
+                    self.agent.set_latest_event(final_event)
+                self.agent.last_event = final_event
+                self._print_verbose_debug(f"agent.chat() returned: {final_event}")
+                self._print_verbose_final_event(final_event)
+                if on_event and final_event is not None:
+                    on_event(final_event)
+                    global_event_bus.publish(final_event)
+            finally:
+                cancel_manager.clear_current_request()
+
         except KeyboardInterrupt:
             # Capture user interrupt / cancellation
             self.console.print("[red]Interrupted by the user.[/red]")