janito 2.25.0__tar.gz → 2.27.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.25.0
+Version: 2.27.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -187,7 +187,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.25.0 → janito-2.27.0}/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.25.0 → janito-2.27.0}/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.25.0 → janito-2.27.0}/docs/changelogs/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 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
+
+- **Chat Mode Shell Enhancements**:
+  - **Unrestricted Mode Command**: Added new `/unrestricted` command to chat mode shell
+    - Toggle unrestricted mode equivalent to the `-u` CLI flag
+    - Real-time switching between restricted and unrestricted modes
+    - Visual feedback with color-coded status messages
+    - Integration with URL whitelist manager for comprehensive security control
+    - **Security Warning**: Clear indication when unrestricted mode is enabled (DANGEROUS - no path or URL restrictions)
+
+### Security
+
+- **Enhanced Security Controls**: 
+  - URL whitelist manager integration with unrestricted mode toggle
+  - Path security controls synchronized with shell state
+  - Real-time security status updates in chat mode
+
 ## [2.25.0] - 2025-08-15
 
 ### Added

janito-2.27.0/docs/changelogs/CHANGELOG_2.26.0.md

@@ -0,0 +1,52 @@
+# Changelog v2.26.0
+
+## [2.26.0] - 2025-08-16
+
+### Added
+
+- **Chat Mode Shell Enhancements**:
+  - **Unrestricted Mode Command**: Added new `/unrestricted` command to chat mode shell
+    - Toggle unrestricted mode equivalent to the `-u` CLI flag
+    - Real-time switching between restricted and unrestricted modes
+    - Visual feedback with color-coded status messages
+    - Integration with URL whitelist manager for comprehensive security control
+    - **Security Warning**: Clear indication when unrestricted mode is enabled (DANGEROUS - no path or URL restrictions)
+
+### Security
+
+- **Enhanced Security Controls**: 
+  - URL whitelist manager integration with unrestricted mode toggle
+  - Path security controls synchronized with shell state
+  - Real-time security status updates in chat mode
+
+### Developer Experience
+
+- **Chat Mode Usability**: 
+  - Seamless switching between security modes without restart
+  - Clear visual indicators for current security state
+  - Consistent behavior between CLI flags and shell commands
+
+### Technical Details
+
+- **Implementation**: New `UnrestrictedShellHandler` class in `janito.cli.chat_mode.shell.commands.unrestricted`
+- **Integration**: Full integration with existing shell state management
+- **Compatibility**: Backward compatible with existing `-u` CLI flag behavior
+
+### Migration Guide
+
+For users upgrading from v2.25.0:
+
+1. **No Breaking Changes**: All existing functionality remains unchanged
+2. **New Command**: Use `/unrestricted` in chat mode shell to toggle unrestricted mode
+3. **CLI Flag**: The `-u` CLI flag continues to work as before
+4. **Security**: Unrestricted mode is clearly indicated with red warning text
+
+### Contributors
+
+- Added unrestricted mode command for enhanced chat mode flexibility
+- Improved security state management in shell commands
+- Enhanced user feedback for security-sensitive operations
+
+---
+
+**Full Changelog**: https://github.com/ikignosis/janito/compare/v2.25.0...v2.26.0

janito-2.27.0/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.25.0 → janito-2.27.0}/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.25.0 → janito-2.27.0}/docs/reference/cli-options.md

@@ -55,14 +55,34 @@ janito --multi  # Start chat mode with multiline input as default
 janito -u -x --read --write "Run a tool with unrestricted paths (DANGEROUS)"
 ```
 
-### ⚠️ Enabling Execution Tools
+### ⚠️ Enabling Tool Permissions
 
-By default, tools that can execute code or shell commands are **disabled** for safety. To enable these tools (such as code execution, shell commands, etc.), use the `--exec` or `-x` flag:
+By default, tools that can read, write, or execute code are **disabled** for safety. You can enable these permissions using individual flags or a convenient shortcut:
 
+#### Individual Permission Flags
+- `-r`, `--read`: Enable tools that require read permissions
+- `-w`, `--write`: Enable tools that require write permissions  
+- `-x`, `--exec`: Enable execution/run tools (code execution, shell commands)
+
+#### Quick Permission Shortcut
+Use `/rwx` prefix to enable all permissions at once:
+```sh
+janito /rwx "Create a Python script and run it"
+```
+
+#### Examples
 ```sh
+# Enable all permissions individually
+janito -r -w -x "Create and run a Python script"
+
+# Enable only execution tools
 janito -x "Run this code: print('Hello, world!')"
+
+# Enable read and write tools
+janito -r -w "Read a file and create a new one"
 ```
-> **Warning:** Enabling execution tools allows running arbitrary code or shell commands. Only use `--exec` if you trust your prompt and environment.
+
+> **Warning:** Enabling execution tools allows running arbitrary code or shell commands. Only use these options if you trust your prompt and environment.
 
 ### ⚠️ Disabling Path Security
 

janito-2.27.0/janito/cli/chat_mode/shell/commands/unrestricted.py

@@ -0,0 +1,40 @@
+"""Unrestricted mode command for chat mode."""
+
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class UnrestrictedShellHandler(ShellCmdHandler):
+    """Toggle unrestricted mode (equivalent to -u CLI flag)."""
+    
+    help_text = "Toggle unrestricted mode (disable path security and URL whitelist)"
+
+    def run(self):
+        """Execute the unrestricted command."""
+        if not self.shell_state:
+            shared_console.print("[red]Error: Shell state not available[/red]")
+            return
+            
+        # Toggle unrestricted mode
+        current_unrestricted = getattr(self.shell_state, 'unrestricted_mode', False)
+        new_unrestricted = not current_unrestricted
+        
+        # Update shell state
+        self.shell_state.unrestricted_mode = new_unrestricted
+        
+        # Update tools adapter
+        if hasattr(self.shell_state, 'tools_adapter'):
+            setattr(self.shell_state.tools_adapter, 'unrestricted_paths', new_unrestricted)
+            
+        # Update URL whitelist manager
+        from janito.tools.url_whitelist import get_url_whitelist_manager
+        whitelist_manager = get_url_whitelist_manager()
+        whitelist_manager.set_unrestricted_mode(new_unrestricted)
+        
+        status = "enabled" if new_unrestricted else "disabled"
+        warning = " (DANGEROUS - no path or URL restrictions)" if new_unrestricted else ""
+        
+        shared_console.print(
+            f"[bold {'red' if new_unrestricted else 'green'}]"
+            f"Unrestricted mode {status}{warning}[/bold {'red' if new_unrestricted else 'green'}]"
+        )

{janito-2.25.0 → janito-2.27.0}/janito/cli/cli_commands/show_config.py

@@ -42,6 +42,30 @@ def handle_show_config(args):
     console.print(f"[bold yellow]Current provider:[/bold yellow] {provider!r}\n")
     if model is not None:
         console.print(f"[bold yellow]Global model:[/bold yellow] {model!r}\n")
+    
+    # Show all configuration values
+    console.print("[bold green]Configuration values:[/bold green]")
+    all_config = config.all()
+    if all_config:
+        for key, value in sorted(all_config.items()):
+            # Hide sensitive values like API keys
+            if 'api_key' in key.lower() and value:
+                masked_value = value[:8] + '***' + value[-4:] if len(value) > 12 else '***'
+                console.print(f"  {key}: {masked_value!r}")
+            elif key == 'providers' and isinstance(value, dict):
+                # Handle nested provider configs with API keys
+                masked_providers = {}
+                for provider_name, provider_config in value.items():
+                    masked_config = dict(provider_config)
+                    if 'api_key' in masked_config and masked_config['api_key']:
+                        api_key = masked_config['api_key']
+                        masked_config['api_key'] = api_key[:8] + '***' + api_key[-4:] if len(api_key) > 12 else '***'
+                    masked_providers[provider_name] = masked_config
+                console.print(f"  {key}: {masked_providers!r}")
+            else:
+                console.print(f"  {key}: {value!r}")
+    else:
+        console.print("  (no configuration values set)")
 
     # Show disabled tools
     from janito.tools.disabled_tools import load_disabled_tools_from_config

{janito-2.25.0 → janito-2.27.0}/janito/cli/main_cli.py

@@ -293,7 +293,8 @@ class JanitoCLI:
         self.parser = argparse.ArgumentParser(
             description="Janito CLI - A tool for running LLM-powered workflows from the command line."
             "\n\nExample usage: janito -p moonshotai -m kimi-k1-8k 'Your prompt here'\n\n"
-            "Use -m or --model to set the model for the session."
+            "Use -m or --model to set the model for the session.",
+
         )
         self._define_args()
         self.args = self.parser.parse_args()
@@ -409,6 +410,17 @@ class JanitoCLI:
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)
             return
+        # Handle /rwx prefix for enabling all permissions
+        if self.args.user_prompt and self.args.user_prompt[0] == '/rwx':
+            self.args.read = True
+            self.args.write = True
+            self.args.exec = True
+            # Remove the /rwx prefix from the prompt
+            self.args.user_prompt = self.args.user_prompt[1:]
+        elif self.args.user_prompt and self.args.user_prompt[0].startswith('/'):
+            # Skip LLM processing for other commands that start with /
+            return
+            
         # If running in single shot mode and --profile is not provided, default to 'developer' profile
         if get_prompt_mode(self.args) == "single_shot" and not getattr(
             self.args, "profile", None

{janito-2.25.0 → janito-2.27.0}/janito/tools/adapters/local/fetch_url.py

@@ -4,6 +4,7 @@ import os
 import json
 from pathlib import Path
 from bs4 import BeautifulSoup
+from typing import Dict, Any, Optional
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
@@ -45,6 +46,9 @@ class FetchUrlTool(ToolBase):
         timeout (int, optional): Timeout in seconds for the HTTP request. Defaults to 10.
         save_to_file (str, optional): File path to save the full resource content. If provided,
             the complete response will be saved to this file instead of being processed.
+        headers (Dict[str, str], optional): Custom HTTP headers to send with the request.
+        cookies (Dict[str, str], optional): Custom cookies to send with the request.
+        follow_redirects (bool, optional): Whether to follow HTTP redirects. Defaults to True.
     Returns:
         str: Extracted text content from the web page, or a warning message. Example:
             - "<main text content...>"
@@ -64,6 +68,22 @@ class FetchUrlTool(ToolBase):
             {}
         )  # In-memory session cache - lifetime matches tool instance
         self._load_cache()
+        
+        # Browser-like session with cookies and headers
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        })
+        
+        # Load cookies from disk if they exist
+        self.cookies_file = self.cache_dir / "cookies.json"
+        self._load_cookies()
 
     def _load_cache(self):
         """Load error cache from disk."""
@@ -84,6 +104,33 @@ class FetchUrlTool(ToolBase):
         except IOError:
             pass  # Silently fail if we can't write cache
 
+    def _load_cookies(self):
+        """Load cookies from disk into session."""
+        if self.cookies_file.exists():
+            try:
+                with open(self.cookies_file, "r", encoding="utf-8") as f:
+                    cookies_data = json.load(f)
+                    for cookie in cookies_data:
+                        self.session.cookies.set(**cookie)
+            except (json.JSONDecodeError, IOError):
+                pass  # Silently fail if we can't load cookies
+
+    def _save_cookies(self):
+        """Save session cookies to disk."""
+        try:
+            cookies_data = []
+            for cookie in self.session.cookies:
+                cookies_data.append({
+                    'name': cookie.name,
+                    'value': cookie.value,
+                    'domain': cookie.domain,
+                    'path': cookie.path
+                })
+            with open(self.cookies_file, "w", encoding="utf-8") as f:
+                json.dump(cookies_data, f, indent=2)
+        except IOError:
+            pass  # Silently fail if we can't write cookies
+
     def _get_cached_error(self, url: str) -> tuple[str, bool]:
         """
         Check if we have a cached error for this URL.
@@ -123,14 +170,15 @@ class FetchUrlTool(ToolBase):
         }
         self._save_cache()
 
-    def _fetch_url_content(self, url: str, timeout: int = 10) -> str:
+    def _fetch_url_content(self, url: str, timeout: int = 10, headers: Optional[Dict[str, str]] = None, 
+                          cookies: Optional[Dict[str, str]] = None, follow_redirects: bool = True) -> str:
         """Fetch URL content and handle HTTP errors.
 
         Implements two-tier caching:
         1. Session cache: In-memory cache for successful responses (lifetime = tool instance)
         2. Error cache: Persistent disk cache for HTTP errors with different expiration times
 
-        Also implements URL whitelist checking.
+        Also implements URL whitelist checking and browser-like behavior.
         """
         # Check URL whitelist
         from janito.tools.url_whitelist import get_url_whitelist_manager
@@ -172,9 +220,27 @@ class FetchUrlTool(ToolBase):
             return cached_error
 
         try:
-            response = requests.get(url, timeout=timeout)
+            # Merge custom headers with default ones
+            request_headers = self.session.headers.copy()
+            if headers:
+                request_headers.update(headers)
+            
+            # Merge custom cookies
+            if cookies:
+                self.session.cookies.update(cookies)
+
+            response = self.session.get(
+                url, 
+                timeout=timeout, 
+                headers=request_headers,
+                allow_redirects=follow_redirects
+            )
             response.raise_for_status()
             content = response.text
+            
+            # Save cookies after successful request
+            self._save_cookies()
+            
             # Cache successful responses in session cache
             self.session_cache[url] = content
             return content
@@ -275,6 +341,9 @@ class FetchUrlTool(ToolBase):
         context_chars: int = 400,
         timeout: int = 10,
         save_to_file: str = None,
+        headers: Dict[str, str] = None,
+        cookies: Dict[str, str] = None,
+        follow_redirects: bool = True,
     ) -> str:
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."), ReportAction.READ)
@@ -284,7 +353,10 @@ class FetchUrlTool(ToolBase):
 
         # Check if we should save to file
         if save_to_file:
-            html_content = self._fetch_url_content(url, timeout=timeout)
+            html_content = self._fetch_url_content(
+                url, timeout=timeout, headers=headers, cookies=cookies, 
+                follow_redirects=follow_redirects
+            )
             if html_content.startswith("Warning:"):
                 return html_content
 
@@ -307,7 +379,10 @@ class FetchUrlTool(ToolBase):
                 return error_msg
 
         # Normal processing path
-        html_content = self._fetch_url_content(url, timeout=timeout)
+        html_content = self._fetch_url_content(
+            url, timeout=timeout, headers=headers, cookies=cookies, 
+            follow_redirects=follow_redirects
+        )
         if html_content.startswith("Warning:"):
             return html_content
 

{janito-2.25.0 → janito-2.27.0}/janito.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.25.0
+Version: 2.27.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -187,7 +187,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.25.0 → janito-2.27.0}/janito.egg-info/SOURCES.txt

@@ -61,6 +61,8 @@ docs/about/why.md
 docs/changelogs/CHANGELOG.md
 docs/changelogs/CHANGELOG_2.16.0.md
 docs/changelogs/CHANGELOG_2.23.0.md
+docs/changelogs/CHANGELOG_2.26.0.md
+docs/changelogs/CHANGELOG_2.27.0.md
 docs/changelogs/RELEASE_NOTES_2.22.0.md
 docs/changelogs/RELEASE_NOTES_2.24.1.md
 docs/code_intelligence/agentic-frameworks-comparison.md
@@ -202,6 +204,7 @@ janito/cli/chat_mode/shell/commands/security_command.py
 janito/cli/chat_mode/shell/commands/session.py
 janito/cli/chat_mode/shell/commands/session_control.py
 janito/cli/chat_mode/shell/commands/tools.py
+janito/cli/chat_mode/shell/commands/unrestricted.py
 janito/cli/chat_mode/shell/commands/utility.py
 janito/cli/chat_mode/shell/commands/verbose.py
 janito/cli/chat_mode/shell/commands/write.py