janito 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/ui/userinterface/__init__.py

@@ -1,16 +0,0 @@
-"""
-User Interface Plugin
-
-User interaction and input tools.
-"""
-
-
-def ask_user(question: str) -> str:
-    """Prompt user for input/clarification"""
-    return f"ask_user(question='{question}')"
-
-
-# Plugin metadata
-__plugin_name__ = "ui.userinterface"
-__plugin_description__ = "User interaction and input"
-__plugin_tools__ = [ask_user]

janito/plugins_backup_20250825_070018/ui/userinterface/tools/ask_user.py

@@ -1,110 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-from rich import print as rich_print
-from janito.i18n import tr
-from rich.panel import Panel
-from prompt_toolkit import PromptSession
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.formatted_text import HTML
-from janito.cli.chat_mode.prompt_style import chat_shell_style
-from prompt_toolkit.styles import Style
-
-toolbar_style = Style.from_dict({"bottom-toolbar": "fg:yellow bg:darkred"})
-
-
-@register_local_tool
-class AskUserTool(ToolBase):
-    """
-    Prompts the user for clarification or input with a question.
-
-    Args:
-        question (str): The question to ask the user. This parameter is required and should be a string containing the prompt or question to display to the user.
-    Returns:
-        str: The user's response as a string. Example:
-            - "Yes"
-            - "No"
-            - "Some detailed answer..."
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "ask_user"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="question")
-    def run(self, question: str) -> str:
-
-        print()  # Print an empty line before the question panel
-        rich_print(Panel.fit(question, title=tr("Question"), style="cyan"))
-
-        bindings = KeyBindings()
-        mode = {"multiline": False}
-
-        @bindings.add("c-r")
-        def _(event):
-            pass
-
-        @bindings.add("f12")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "Do It"
-            buf.validate_and_handle()
-
-        @bindings.add("f2")
-        def _(event):
-            buf = event.app.current_buffer
-            buf.text = "F2"
-            buf.validate_and_handle()
-
-        # Use shared CLI styles
-
-        # prompt_style contains the prompt area and input background
-        # toolbar_style contains the bottom-toolbar styling
-
-        # Use the shared chat_shell_style for input styling only
-        style = chat_shell_style
-
-        def get_toolbar():
-            f12_hint = " F2: F2 | F12: Do It"
-            if mode["multiline"]:
-                return HTML(
-                    f"<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>{f12_hint}"
-                )
-            else:
-                return HTML(
-                    f"<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>{f12_hint}"
-                )
-
-        session = PromptSession(
-            multiline=False,
-            key_bindings=bindings,
-            editing_mode=EditingMode.EMACS,
-            bottom_toolbar=get_toolbar,
-            style=style,
-        )
-
-        prompt_icon = HTML("<inputline>💬 </inputline>")
-
-        while True:
-            response = session.prompt(prompt_icon)
-            if not mode["multiline"] and response.strip() == "/multi":
-                mode["multiline"] = True
-                session.multiline = True
-                continue
-            elif mode["multiline"] and response.strip() == "/single":
-                mode["multiline"] = False
-                session.multiline = False
-                continue
-            else:
-                sanitized = response.strip()
-                try:
-                    sanitized.encode("utf-8")
-                except UnicodeEncodeError:
-                    sanitized = sanitized.encode("utf-8", errors="replace").decode(
-                        "utf-8"
-                    )
-                    rich_print(
-                        "[yellow]Warning: Some characters in your input were not valid UTF-8 and have been replaced.[/yellow]"
-                    )
-                return sanitized

janito/plugins_backup_20250825_070018/web/__init__.py

@@ -1,7 +0,0 @@
-"""
-Web Tools Plugin Package
-
-Contains web scraping, browsing, and URL operations.
-"""
-
-__all__ = ["webtools"]

janito/plugins_backup_20250825_070018/web/webtools/__init__.py

@@ -1,33 +0,0 @@
-"""
-Web Tools Plugin
-
-Web scraping, browsing, and URL operations.
-"""
-
-from typing import Optional, Dict, List
-
-
-def fetch_url(
-    url: str,
-    search_strings: Optional[List[str]] = None,
-    max_length: int = 5000,
-    timeout: int = 10,
-) -> str:
-    """Download web pages with advanced options"""
-    return f"fetch_url(url='{url}', search={len(search_strings or [])} terms)"
-
-
-def open_url(url: str) -> str:
-    """Open URLs in default browser"""
-    return f"open_url(url='{url}')"
-
-
-def open_html_in_browser(path: str) -> str:
-    """Open local HTML files in browser"""
-    return f"open_html_in_browser(path='{path}')"
-
-
-# Plugin metadata
-__plugin_name__ = "web.webtools"
-__plugin_description__ = "Web scraping, browsing, and URL operations"
-__plugin_tools__ = [fetch_url, open_url, open_html_in_browser]

janito/plugins_backup_20250825_070018/web/webtools/tools/fetch_url.py

@@ -1,458 +0,0 @@
-import requests
-import time
-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
-from janito.i18n import tr
-from janito.tools.tool_utils import pluralize
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-class FetchUrlTool(ToolBase):
-    """
-    Fetch the content of a web page and extract its text.
-
-    This tool implements a **session-based caching mechanism** that provides
-    **in-memory caching** for the lifetime of the tool instance. URLs are cached
-    in RAM during the session, providing instant access to previously fetched
-    content without making additional HTTP requests.
-
-    **Session Cache Behavior:**
-    - **Lifetime**: Cache exists for the lifetime of the FetchUrlTool instance
-    - **Scope**: In-memory (RAM) cache, not persisted to disk
-    - **Storage**: Successful responses are cached as raw HTML content
-    - **Key**: Cache key is the exact URL string
-    - **Invalidation**: Cache is automatically cleared when the tool instance is destroyed
-    - **Performance**: Subsequent requests for the same URL return instantly
-
-    **Error Cache Behavior:**
-    - HTTP 403 errors: Cached for 24 hours (more permanent)
-    - HTTP 404 errors: Cached for 1 hour (temporary)
-    - Other 4xx errors: Cached for 30 minutes
-    - 5xx errors: Not cached (retried on each request)
-
-    Args:
-        url (str): The URL of the web page to fetch.
-        search_strings (list[str], optional): Strings to search for in the page content.
-        max_length (int, optional): Maximum number of characters to return. Defaults to 5000.
-        max_lines (int, optional): Maximum number of lines to return. Defaults to 200.
-        context_chars (int, optional): Characters of context around search matches. Defaults to 400.
-        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...>"
-            - "No lines found for the provided search strings."
-            - "Warning: Empty URL provided. Operation skipped."
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "fetch_url"
-
-    def __init__(self):
-        super().__init__()
-        self.cache_dir = Path.home() / ".janito" / "cache" / "fetch_url"
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.cache_file = self.cache_dir / "error_cache.json"
-        self.session_cache = (
-            {}
-        )  # 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."""
-        if self.cache_file.exists():
-            try:
-                with open(self.cache_file, "r", encoding="utf-8") as f:
-                    self.error_cache = json.load(f)
-            except (json.JSONDecodeError, IOError):
-                self.error_cache = {}
-        else:
-            self.error_cache = {}
-
-    def _save_cache(self):
-        """Save error cache to disk."""
-        try:
-            with open(self.cache_file, "w", encoding="utf-8") as f:
-                json.dump(self.error_cache, f, indent=2)
-        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.
-        Returns (error_message, is_cached) tuple.
-        """
-        if url not in self.error_cache:
-            return None, False
-
-        entry = self.error_cache[url]
-        current_time = time.time()
-
-        # Different expiration times for different status codes
-        if entry["status_code"] == 403:
-            # Cache 403 errors for 24 hours (more permanent)
-            expiration_time = 24 * 3600
-        elif entry["status_code"] == 404:
-            # Cache 404 errors for 1 hour (more temporary)
-            expiration_time = 3600
-        else:
-            # Cache other 4xx errors for 30 minutes
-            expiration_time = 1800
-
-        if current_time - entry["timestamp"] > expiration_time:
-            # Cache expired, remove it
-            del self.error_cache[url]
-            self._save_cache()
-            return None, False
-
-        return entry["message"], True
-
-    def _cache_error(self, url: str, status_code: int, message: str):
-        """Cache an HTTP error response."""
-        self.error_cache[url] = {
-            "status_code": status_code,
-            "message": message,
-            "timestamp": time.time(),
-        }
-        self._save_cache()
-
-    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 and browser-like behavior.
-        """
-        # Check URL whitelist
-        from janito.tools.url_whitelist import get_url_whitelist_manager
-
-        whitelist_manager = get_url_whitelist_manager()
-
-        if not whitelist_manager.is_url_allowed(url):
-            error_message = tr("Blocked")
-            self.report_error(
-                tr("❗ Blocked"),
-                ReportAction.READ,
-            )
-            return error_message
-
-        # Check session cache first
-        if url in self.session_cache:
-            return self.session_cache[url]
-
-        # Check persistent cache for known errors
-        cached_error, is_cached = self._get_cached_error(url)
-        if cached_error:
-            self.report_warning(
-                tr(
-                    "ℹ️ Using cached HTTP error for URL: {url}",
-                    url=url,
-                ),
-                ReportAction.READ,
-            )
-            return cached_error
-
-        try:
-            # 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
-        except requests.exceptions.HTTPError as http_err:
-            status_code = http_err.response.status_code if http_err.response else None
-
-            # Map status codes to descriptions
-            status_descriptions = {
-                400: "Bad Request",
-                401: "Unauthorized",
-                403: "Forbidden",
-                404: "Not Found",
-                405: "Method Not Allowed",
-                408: "Request Timeout",
-                409: "Conflict",
-                410: "Gone",
-                413: "Payload Too Large",
-                414: "URI Too Long",
-                415: "Unsupported Media Type",
-                429: "Too Many Requests",
-                500: "Internal Server Error",
-                501: "Not Implemented",
-                502: "Bad Gateway",
-                503: "Service Unavailable",
-                504: "Gateway Timeout",
-                505: "HTTP Version Not Supported",
-            }
-
-            if status_code and 400 <= status_code < 500:
-                description = status_descriptions.get(status_code, "Client Error")
-                error_message = f"HTTP {status_code} {description}"
-                # Cache 403 and 404 errors
-                if status_code in [403, 404]:
-                    self._cache_error(url, status_code, error_message)
-
-                self.report_error(
-                    f"❗ HTTP {status_code} {description}",
-                    ReportAction.READ,
-                )
-                return error_message
-            else:
-                status_code_str = str(status_code) if status_code else "Error"
-                description = status_descriptions.get(
-                    status_code,
-                    (
-                        "Server Error"
-                        if status_code and status_code >= 500
-                        else "Client Error"
-                    ),
-                )
-                self.report_error(
-                    f"❗ HTTP {status_code_str} {description}",
-                    ReportAction.READ,
-                )
-                return f"HTTP {status_code_str} {description}"
-        except requests.exceptions.ConnectionError as conn_err:
-            self.report_error(
-                "❗ Network Error",
-                ReportAction.READ,
-            )
-            return f"Network Error: Failed to connect to {url}"
-        except requests.exceptions.Timeout as timeout_err:
-            self.report_error(
-                "❗ Timeout Error",
-                ReportAction.READ,
-            )
-            return f"Timeout Error: Request timed out after {timeout} seconds"
-        except requests.exceptions.RequestException as req_err:
-            self.report_error(
-                "❗ Request Error",
-                ReportAction.READ,
-            )
-            return f"Request Error: {str(req_err)}"
-        except Exception as err:
-            self.report_error(
-                "❗ Error fetching URL",
-                ReportAction.READ,
-            )
-            return f"Error: {str(err)}"
-
-    def _extract_and_clean_text(self, html_content: str) -> str:
-        """Extract and clean text from HTML content."""
-        soup = BeautifulSoup(html_content, "html.parser")
-        text = soup.get_text(separator="\n")
-
-        # Clean up excessive whitespace
-        lines = [line.strip() for line in text.splitlines() if line.strip()]
-        return "\n".join(lines)
-
-    def _filter_by_search_strings(
-        self, text: str, search_strings: list[str], context_chars: int
-    ) -> str:
-        """Filter text by search strings with context."""
-        filtered = []
-        for s in search_strings:
-            idx = text.find(s)
-            if idx != -1:
-                start = max(0, idx - context_chars)
-                end = min(len(text), idx + len(s) + context_chars)
-                snippet = text[start:end]
-                filtered.append(snippet)
-
-        if filtered:
-            return "\n...\n".join(filtered)
-        else:
-            return tr("No lines found for the provided search strings.")
-
-    def _apply_limits(self, text: str, max_length: int, max_lines: int) -> str:
-        """Apply length and line limits to text."""
-        # Apply length limit
-        if len(text) > max_length:
-            text = text[:max_length] + "\n... (content truncated due to length limit)"
-
-        # Apply line limit
-        lines = text.splitlines()
-        if len(lines) > max_lines:
-            text = (
-                "\n".join(lines[:max_lines])
-                + "\n... (content truncated due to line limit)"
-            )
-
-        return text
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="url")
-    def run(
-        self,
-        url: str,
-        search_strings: list[str] = None,
-        max_length: int = 5000,
-        max_lines: int = 200,
-        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)
-            return tr("Warning: Empty URL provided. Operation skipped.")
-
-        self.report_action(tr("🌐 Fetch URL '{url}' ...", url=url), ReportAction.READ)
-
-        # Check if we should save to file
-        if save_to_file:
-            html_content = self._fetch_url_content(
-                url,
-                timeout=timeout,
-                headers=headers,
-                cookies=cookies,
-                follow_redirects=follow_redirects,
-            )
-            if (
-                html_content.startswith("HTTP Error ")
-                or html_content == "Error"
-                or html_content == "Blocked"
-            ):
-                return html_content
-
-            try:
-                with open(save_to_file, "w", encoding="utf-8") as f:
-                    f.write(html_content)
-                file_size = len(html_content)
-                self.report_success(
-                    tr(
-                        "✅ Saved {size} bytes to {file}",
-                        size=file_size,
-                        file=save_to_file,
-                    ),
-                    ReportAction.READ,
-                )
-                return tr("Successfully saved content to: {file}", file=save_to_file)
-            except IOError as e:
-                error_msg = tr("Error saving to file: {error}", error=str(e))
-                self.report_error(error_msg, ReportAction.READ)
-                return error_msg
-
-        # Normal processing path
-        html_content = self._fetch_url_content(
-            url,
-            timeout=timeout,
-            headers=headers,
-            cookies=cookies,
-            follow_redirects=follow_redirects,
-        )
-        if (
-            html_content.startswith("HTTP Error ")
-            or html_content == "Error"
-            or html_content == "Blocked"
-        ):
-            return html_content
-
-        # Extract and clean text
-        text = self._extract_and_clean_text(html_content)
-
-        # Filter by search strings if provided
-        if search_strings:
-            text = self._filter_by_search_strings(text, search_strings, context_chars)
-
-        # Apply limits
-        text = self._apply_limits(text, max_length, max_lines)
-
-        # Report success
-        num_lines = len(text.splitlines())
-        total_chars = len(text)
-        self.report_success(
-            tr(
-                "✅ {num_lines} {line_word}, {chars} chars",
-                num_lines=num_lines,
-                line_word=pluralize("line", num_lines),
-                chars=total_chars,
-            ),
-            ReportAction.READ,
-        )
-        return text

janito/plugins_backup_20250825_070018/web/webtools/tools/open_html_in_browser.py

@@ -1,51 +0,0 @@
-import os
-import webbrowser
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_local_tool
-class OpenHtmlInBrowserTool(ToolBase):
-    """
-    Open the supplied HTML file in the default web browser.
-
-    Args:
-        path (str): Path to the HTML file to open.
-    Returns:
-        str: Status message indicating the result.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "open_html_in_browser"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str) -> str:
-        if not path.strip():
-            self.report_warning(tr("ℹ️ Empty file path provided."))
-            return tr("Warning: Empty file path provided. Operation skipped.")
-        if not os.path.isfile(path):
-            self.report_error(tr("❗ File does not exist: {path}", path=path))
-            return tr("Warning: File does not exist: {path}", path=path)
-        if not path.lower().endswith((".html", ".htm")):
-            self.report_warning(tr("⚠️ Not an HTML file: {path}", path=path))
-            return tr("Warning: Not an HTML file: {path}", path=path)
-        url = "file://" + os.path.abspath(path)
-        self.report_action(
-            tr("📖 Opening HTML file in browser: {path}", path=path), ReportAction.READ
-        )
-        try:
-            webbrowser.open(url)
-        except Exception as err:
-            self.report_error(
-                tr("❗ Error opening HTML file: {path}: {err}", path=path, err=str(err))
-            )
-            return tr(
-                "Warning: Error opening HTML file: {path}: {err}",
-                path=path,
-                err=str(err),
-            )
-        self.report_success(tr("✅ HTML file opened in browser: {path}", path=path))
-        return tr("HTML file opened in browser: {path}", path=path)