janito 2.33.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

janito/plugins/tools/validate_file_syntax/markdown_validator.py

@@ -0,0 +1,109 @@
+from janito.i18n import tr
+import re
+
+
+def validate_markdown(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+    lines = content.splitlines()
+    errors = []
+    errors.extend(_check_header_space(lines))
+    errors.extend(_check_unclosed_code_block(content))
+    errors.extend(_check_unclosed_links_images(lines))
+    errors.extend(_check_list_formatting(lines))
+    errors.extend(_check_unclosed_inline_code(content))
+    return _build_markdown_result(errors)
+
+
+def _check_header_space(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if re.match(r"^#+[^ #]", line):
+            errors.append(f"Line {i}: Header missing space after # | {line.strip()}")
+    return errors
+
+
+def _check_unclosed_code_block(content):
+    errors = []
+    if content.count("```") % 2 != 0:
+        errors.append("Unclosed code block (```) detected")
+    return errors
+
+
+def _check_unclosed_links_images(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if re.search(r"\[[^\]]*\]\([^)]+$", line):
+            errors.append(
+                f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
+            )
+    return errors
+
+
+def _is_table_line(line):
+    return line.lstrip().startswith("|")
+
+
+def _list_item_missing_space(line):
+    return re.match(r"^[-*+][^ \n]", line)
+
+
+def _should_skip_list_item(line):
+    stripped = line.strip()
+    return stripped.startswith("*") and stripped.endswith("*") and len(stripped) > 2
+
+
+def _needs_blank_line_before_bullet(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_list = bool(re.match(r"^\s*[-*+] ", prev_line))
+    return not prev_is_list and prev_line.strip() != ""
+
+
+def _needs_blank_line_before_numbered(lines, i):
+    if i <= 1:
+        return False
+    prev_line = lines[i - 2]
+    prev_is_numbered_list = bool(re.match(r"^\s*\d+\. ", prev_line))
+    return not prev_is_numbered_list and prev_line.strip() != ""
+
+
+def _check_list_formatting(lines):
+    errors = []
+    for i, line in enumerate(lines, 1):
+        if _is_table_line(line):
+            continue
+        if _list_item_missing_space(line):
+            if not _should_skip_list_item(line):
+                errors.append(
+                    f"Line {i}: List item missing space after bullet | {line.strip()}"
+                )
+        if re.match(r"^\s*[-*+] ", line):
+            if _needs_blank_line_before_bullet(lines, i):
+                errors.append(
+                    f"Line {i}: List should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
+        if re.match(r"^\s*\d+\. ", line):
+            if _needs_blank_line_before_numbered(lines, i):
+                errors.append(
+                    f"Line {i}: Numbered list should be preceded by a blank line for compatibility with MkDocs and other Markdown parsers | {line.strip()}"
+                )
+    return errors
+
+
+def _check_unclosed_inline_code(content):
+    errors = []
+    if content.count("`") % 2 != 0:
+        errors.append("Unclosed inline code (`) detected")
+    return errors
+
+
+def _build_markdown_result(errors):
+    if errors:
+        msg = tr(
+            "⚠️ Warning: Markdown syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ OK"

janito/plugins/tools/validate_file_syntax/ps1_validator.py

@@ -0,0 +1,32 @@
+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/tools/validate_file_syntax/python_validator.py

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

janito/plugins/tools/validate_file_syntax/xml_validator.py

@@ -0,0 +1,11 @@
+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/tools/validate_file_syntax/yaml_validator.py

@@ -0,0 +1,6 @@
+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/tools/view_file.py

@@ -0,0 +1,172 @@
+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/ui/__init__.py

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

janito/plugins/ui/userinterface/__init__.py

@@ -0,0 +1,16 @@
+"""
+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/ui/userinterface/tools/ask_user.py

@@ -0,0 +1,110 @@
+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/web/__init__.py

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

janito/plugins/web/webtools/__init__.py

@@ -0,0 +1,33 @@
+"""
+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]