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

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/ps1_validator.py

@@ -1,32 +0,0 @@
-from janito.i18n import tr
-import re
-
-
-def validate_ps1(path: str) -> str:
-    with open(path, "r", encoding="utf-8") as f:
-        content = f.read()
-    errors = []
-    # Unmatched curly braces
-    if content.count("{") != content.count("}"):
-        errors.append("Unmatched curly braces { }")
-    # Unmatched parentheses
-    if content.count("(") != content.count(")"):
-        errors.append("Unmatched parentheses ( )")
-    # Unmatched brackets
-    if content.count("[") != content.count("]"):
-        errors.append("Unmatched brackets [ ]")
-    # Unclosed string literals
-    for quote in ["'", '"']:
-        unescaped = re.findall(rf"(?<!\\){quote}", content)
-        if len(unescaped) % 2 != 0:
-            errors.append(f"Unclosed string literal ({quote}) detected")
-    # Unclosed block comments <# ... #>
-    if content.count("<#") != content.count("#>"):
-        errors.append("Unclosed block comment (<# ... #>)")
-    if errors:
-        msg = tr(
-            "⚠️ Warning: PowerShell syntax issues found:\n{errors}",
-            errors="\n".join(errors),
-        )
-        return msg
-    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/python_validator.py

@@ -1,5 +0,0 @@
-def validate_python(path: str) -> str:
-    import py_compile
-
-    py_compile.compile(path, doraise=True)
-    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/xml_validator.py

@@ -1,11 +0,0 @@
-from janito.i18n import tr
-
-
-def validate_xml(path: str) -> str:
-    try:
-        from lxml import etree
-    except ImportError:
-        return tr("⚠️ lxml not installed. Cannot validate XML.")
-    with open(path, "rb") as f:
-        etree.parse(f)
-    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/validate_file_syntax/yaml_validator.py

@@ -1,6 +0,0 @@
-def validate_yaml(path: str) -> str:
-    import yaml
-
-    with open(path, "r", encoding="utf-8") as f:
-        yaml.safe_load(f)
-    return "✅ OK"

janito/plugins_backup_20250825_070018/tools/view_file.py

@@ -1,172 +0,0 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
-from janito.tools.tool_utils import pluralize
-from janito.i18n import tr
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-@register_core_tool
-class ViewFile(ToolBase):
-    """
-    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
-
-    Args:
-        path (str): Path to the file to read lines from.
-        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
-        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
-
-    To read the full file, just provide path and leave from_line and to_line unset.
-
-    Returns:
-        str: File content with a header indicating the file name and line range. Example:
-            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
-            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
-            - "Error reading file: <error message>"
-            - "❗ not found"
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "view_file"
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
-    def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
-        import os
-        from janito.tools.tool_utils import display_path
-        from janito.tools.path_utils import expand_path
-
-        path = expand_path(path)
-        disp_path = display_path(path)
-        self.report_action(
-            tr("📖 View '{disp_path}'", disp_path=disp_path),
-            ReportAction.READ,
-        )
-        try:
-            if os.path.isdir(path):
-                return self._list_directory(path, disp_path)
-            lines = self._read_file_lines(path)
-            selected, selected_len, total_lines = self._select_lines(
-                lines, from_line, to_line
-            )
-            self._report_success(selected_len, from_line, to_line, total_lines)
-            header = self._format_header(
-                disp_path, from_line, to_line, selected_len, total_lines
-            )
-            return header + "".join(selected)
-        except FileNotFoundError as e:
-            self.report_warning(tr("❗ not found"))
-            return f"Error reading file: {e}"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e))
-            return tr("Error reading file: {error}", error=e)
-
-    def _list_directory(self, path, disp_path):
-        import os
-
-        try:
-            entries = os.listdir(path)
-            entries.sort()
-            # Suffix subdirectories with '/'
-            formatted_entries = []
-            for entry in entries:
-                full_path = os.path.join(path, entry)
-                if os.path.isdir(full_path):
-                    formatted_entries.append(entry + "/")
-                else:
-                    formatted_entries.append(entry)
-            header = (
-                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
-            )
-            listing = "\n".join(formatted_entries)
-            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
-            return header + listing + "\n"
-        except Exception as e:
-            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
-            return tr("Error listing directory: {error}", error=e)
-
-    def _read_file_lines(self, path):
-        """Read all lines from the file."""
-        with open(path, "r", encoding="utf-8", errors="replace") as f:
-            return f.readlines()
-
-    def _select_lines(self, lines, from_line, to_line):
-        """Select the requested lines and return them with their count and total lines."""
-        selected = lines[
-            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
-        ]
-        selected_len = len(selected)
-        total_lines = len(lines)
-        return selected, selected_len, total_lines
-
-    def _report_success(self, selected_len, from_line, to_line, total_lines):
-        """Report the success message after reading lines."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = to_line >= total_lines or selected_len < requested
-            if at_end:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} (end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                    )
-                )
-            elif to_line < total_lines:
-                self.report_success(
-                    tr(
-                        " ✅ {selected_len} {line_word} ({remaining} to end)",
-                        selected_len=selected_len,
-                        line_word=pluralize("line", selected_len),
-                        remaining=total_lines - to_line,
-                    )
-                )
-        else:
-            self.report_success(
-                tr(
-                    " ✅ {selected_len} {line_word} (all)",
-                    selected_len=selected_len,
-                    line_word=pluralize("line", selected_len),
-                )
-            )
-
-    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
-        """Format the header for the output."""
-        if from_line and to_line:
-            requested = to_line - from_line + 1
-            at_end = selected_len < requested or to_line >= total_lines
-            if at_end:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                )
-            else:
-                return tr(
-                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
-                    disp_path=disp_path,
-                    from_line=from_line,
-                    to_line=to_line,
-                    total_lines=total_lines,
-                )
-        elif from_line:
-            return tr(
-                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
-                disp_path=disp_path,
-                from_line=from_line,
-                total_lines=total_lines,
-            )
-        else:
-            return tr(
-                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
-                disp_path=disp_path,
-                total_lines=total_lines,
-            )
-
-    def _handle_read_error(self, e):
-        """Handle file read errors and report appropriately."""
-        if isinstance(e, FileNotFoundError):
-            self.report_error(tr("❗ not found"), ReportAction.READ)
-            return tr("❗ not found")
-        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
-        return tr("Error reading file: {error}", error=e)

janito/plugins_backup_20250825_070018/ui/__init__.py

@@ -1,7 +0,0 @@
-"""
-User Interface Plugin Package
-
-Contains user interaction and interface tools.
-"""
-
-__all__ = ["userinterface"]

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]