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

janito/plugins/tools/get_file_outline/python_outline.py

@@ -0,0 +1,303 @@
+import re
+from typing import List
+
+
+def handle_assignment(idx, assign_match, outline):
+    var_name = assign_match.group(2)
+    var_type = "const" if var_name.isupper() else "var"
+    outline.append(
+        {
+            "type": var_type,
+            "name": var_name,
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def handle_main(idx, outline):
+    outline.append(
+        {
+            "type": "main",
+            "name": "__main__",
+            "start": idx + 1,
+            "end": idx + 1,
+            "parent": "",
+            "docstring": "",
+        }
+    )
+
+
+def close_stack_objects(idx, indent, stack, obj_ranges):
+    while stack and indent < stack[-1][2]:
+        popped = stack.pop()
+        obj_ranges.append((popped[0], popped[1], popped[3], idx, popped[4], popped[2]))
+
+
+def close_last_top_obj(idx, last_top_obj, stack, obj_ranges):
+    if last_top_obj and last_top_obj in stack:
+        stack.remove(last_top_obj)
+        obj_ranges.append(
+            (
+                last_top_obj[0],
+                last_top_obj[1],
+                last_top_obj[3],
+                idx,
+                last_top_obj[4],
+                last_top_obj[2],
+            )
+        )
+        return None
+    return last_top_obj
+
+
+def handle_class(idx, class_match, indent, stack, last_top_obj):
+    name = class_match.group(2)
+    parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+    obj = ("class", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def handle_function(idx, func_match, indent, stack, last_top_obj):
+    name = func_match.group(2)
+    parent = ""
+    for s in reversed(stack):
+        if s[0] == "class" and indent > s[2]:
+            parent = s[1]
+            break
+    obj = ("function", name, indent, idx + 1, parent)
+    stack.append(obj)
+    if indent == 0:
+        last_top_obj = obj
+    return last_top_obj
+
+
+def process_line(idx, line, regexes, stack, obj_ranges, outline, last_top_obj):
+    class_pat, func_pat, assign_pat, main_pat = regexes
+    class_match = class_pat.match(line)
+    func_match = func_pat.match(line)
+    assign_match = assign_pat.match(line)
+    indent = len(line) - len(line.lstrip())
+    # If a new top-level class or function starts, close the previous one
+    if (class_match or func_match) and indent == 0 and last_top_obj:
+        last_top_obj = close_last_top_obj(idx, last_top_obj, stack, obj_ranges)
+    if class_match:
+        last_top_obj = handle_class(idx, class_match, indent, stack, last_top_obj)
+    elif func_match:
+        last_top_obj = handle_function(idx, func_match, indent, stack, last_top_obj)
+    elif assign_match and indent == 0:
+        handle_assignment(idx, assign_match, outline)
+    main_match = main_pat.match(line)
+    if main_match:
+        handle_main(idx, outline)
+    close_stack_objects(idx, indent, stack, obj_ranges)
+    return last_top_obj
+
+
+def extract_signature_and_decorators(lines, start_idx):
+    """
+    Extracts the signature line and leading decorators for a given function/class/method.
+    Returns (signature:str, decorators:List[str], signature_lineno:int)
+    """
+    decorators = []
+    sig_line = None
+    sig_lineno = start_idx
+    for i in range(start_idx - 1, -1, -1):
+        striped = lines[i].strip()
+        if striped.startswith("@"):
+            decorators.insert(0, striped)
+            sig_lineno = i
+        elif not striped:
+            continue
+        else:
+            break
+    # Find the signature line itself
+    for k in range(start_idx, len(lines)):
+        striped = lines[k].strip()
+        if striped.startswith("def ") or striped.startswith("class "):
+            sig_line = striped
+            sig_lineno = k
+            break
+    return sig_line, decorators, sig_lineno
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""
+
+
+def build_outline_entry(obj, lines, outline):
+    obj_type, name, start, end, parent, indent = obj
+    # Determine if this is a method
+    if obj_type == "function" and parent:
+        outline_type = "method"
+    elif obj_type == "function":
+        outline_type = "function"
+    else:
+        outline_type = obj_type
+    docstring = extract_docstring(lines, start, end)
+    outline.append(
+        {
+            "type": outline_type,
+            "name": name,
+            "start": start,
+            "end": end,
+            "parent": parent,
+            "docstring": docstring,
+        }
+    )
+
+
+def process_lines(lines, regexes):
+    outline = []
+    stack = []
+    obj_ranges = []
+    last_top_obj = None
+    for idx, line in enumerate(lines):
+        last_top_obj = process_line(
+            idx, line, regexes, stack, obj_ranges, outline, last_top_obj
+        )
+    # Close any remaining open objects
+    for popped in stack:
+        obj_ranges.append(
+            (popped[0], popped[1], popped[3], len(lines), popped[4], popped[2])
+        )
+    return outline, obj_ranges
+
+
+def build_outline(obj_ranges, lines, outline):
+    for obj in obj_ranges:
+        build_outline_entry(obj, lines, outline)
+    return outline
+
+
+def parse_python_outline(lines: List[str]):
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    outline = []
+    stack = []
+    obj_ranges = []
+    last_top_obj = None
+    for idx, line in enumerate(lines):
+        class_match = class_pat.match(line)
+        func_match = func_pat.match(line)
+        assign_match = assign_pat.match(line)
+        indent = len(line) - len(line.lstrip())
+        parent = ""
+        for s in reversed(stack):
+            if s[0] == "class" and indent > s[2]:
+                parent = s[1]
+                break
+        if class_match:
+            obj = ("class", class_match.group(2), idx + 1, None, parent, indent)
+            stack.append(obj)
+            last_top_obj = obj
+        elif func_match:
+            obj = ("function", func_match.group(2), idx + 1, None, parent, indent)
+            stack.append(obj)
+            last_top_obj = obj
+        elif assign_match and indent == 0:
+            outline.append(
+                {
+                    "type": "const" if assign_match.group(2).isupper() else "var",
+                    "name": assign_match.group(2),
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                    "signature": line.strip(),
+                    "decorators": [],
+                    "docstring": "",
+                }
+            )
+        if line.strip().startswith("if __name__ == "):
+            outline.append(
+                {
+                    "type": "main",
+                    "name": "__main__",
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                    "signature": line.strip(),
+                    "decorators": [],
+                    "docstring": "",
+                }
+            )
+        # Close stack objects if indent falls back
+        while stack and indent <= stack[-1][5] and idx + 1 > stack[-1][2]:
+            finished = stack.pop()
+            outline_entry = finished[:2] + (
+                finished[2],
+                idx + 1,
+                finished[4],
+                finished[5],
+            )
+            build_outline_entry(outline_entry, lines, outline)
+    # Close any remaining objects
+    while stack:
+        finished = stack.pop()
+        outline_entry = finished[:2] + (
+            finished[2],
+            len(lines),
+            finished[4],
+            finished[5],
+        )
+        build_outline_entry(outline_entry, lines, outline)
+    return outline
+
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    regexes = (class_pat, func_pat, assign_pat, main_pat)
+    outline, obj_ranges = process_lines(lines, regexes)
+    return build_outline(obj_ranges, lines, outline)
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""

janito/plugins/tools/get_file_outline/search_outline.py

@@ -0,0 +1,36 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+class SearchOutlineTool(ToolBase):
+    """
+    Tool for searching outlines in files.
+
+    Args:
+        path (str): Path to the file for which to generate an outline.
+    Returns:
+        str: Outline search result or status message.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "search_outline"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str) -> str:
+        from janito.tools.tool_utils import display_path
+        from janito.i18n import tr
+
+        self.report_action(
+            tr(
+                "🔍 Searching for outline in '{disp_path}'",
+                disp_path=display_path(path),
+            ),
+            ReportAction.READ,
+        )
+        # ... rest of implementation ...
+        # Example warnings and successes:
+        # self.report_warning(tr("No files found with supported extensions."))
+        # self.report_warning(tr("Error reading {path}: {error}", path=path, error=e))
+        # self.report_success(tr("✅ {count} {match_word} found", count=len(output), match_word=pluralize('match', len(output))))
+        pass

janito/plugins/tools/move_file.py

@@ -0,0 +1,131 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from janito.plugins.tools.decorators import register_core_tool
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_core_tool
+class MoveFile(ToolBase):
+    """
+    Move a file or directory from src_path to dest_path.
+
+    Args:
+        src_path (str): Source file or directory path.
+        dest_path (str): Destination file or directory path.
+        overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    permissions = ToolPermissions(read=True, write=True)
+    tool_name = "move_file"
+
+    def run(
+        self,
+        src_path: str,
+        dest_path: str,
+        overwrite: bool = False,
+        backup: bool = False,
+    ) -> str:
+        src = expand_path(src_path)
+        dest = expand_path(dest_path)
+        original_src = src_path
+        original_dest = dest_path
+        disp_src = display_path(original_src)
+        disp_dest = display_path(original_dest)
+        backup_path = None
+
+        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
+        if not valid:
+            return err_msg
+
+        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
+        if dest_result is not None:
+            backup_path, err_msg = dest_result
+            if err_msg:
+                return err_msg
+
+        try:
+            self.report_action(
+                tr(
+                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
+                    disp_src=disp_src,
+                    disp_dest=disp_dest,
+                ),
+                ReportAction.UPDATE,
+            )
+            shutil.move(src, dest)
+            self.report_success(tr("✅ Move complete."))
+            msg = tr("✅ Move complete.")
+
+            return msg
+        except Exception as e:
+            self.report_error(tr("❌ Error moving: {error}", error=e))
+            return tr("❌ Error moving: {error}", error=e)
+
+    def _validate_source(self, src, disp_src):
+        if not os.path.exists(src):
+            self.report_error(
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+            )
+            return (
+                False,
+                False,
+                False,
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
+            )
+        is_src_file = os.path.isfile(src)
+        is_src_dir = os.path.isdir(src)
+        if not (is_src_file or is_src_dir):
+            self.report_error(
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                )
+            )
+            return (
+                False,
+                False,
+                False,
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                ),
+            )
+        return True, is_src_file, is_src_dir, None
+
+    def _handle_destination(self, dest, disp_dest, overwrite, backup):
+        backup_path = None
+        if os.path.exists(dest):
+            if not overwrite:
+                self.report_error(
+                    tr(
+                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
+                        disp_dest=disp_dest,
+                    ),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
+                    disp_dest=disp_dest,
+                )
+
+            try:
+                if os.path.isfile(dest):
+                    os.remove(dest)
+                elif os.path.isdir(dest):
+                    shutil.rmtree(dest)
+            except Exception as e:
+                self.report_error(
+                    tr("❌ Error removing destination before move: {error}", error=e),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❌ Error removing destination before move: {error}", error=e
+                )
+        return backup_path, None

janito/plugins/tools/open_html_in_browser.py

@@ -0,0 +1,51 @@
+import os
+import webbrowser
+from janito.plugins.tools.decorators import register_core_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_core_tool
+class OpenHtmlInBrowser(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)

janito/plugins/tools/open_url.py

@@ -0,0 +1,37 @@
+import webbrowser
+from janito.plugins.tools.decorators import register_core_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_core_tool
+class OpenUrl(ToolBase):
+    """
+    Open the supplied URL or local file in the default web browser.
+
+    Args:
+        url (str): The URL or local file path (as a file:// URL) to open. Supports both web URLs (http, https) and local files (file://).
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "open_url"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="url")
+    def run(self, url: str) -> str:
+        if not url.strip():
+            self.report_warning(tr("ℹ️ Empty URL provided."))
+            return tr("Warning: Empty URL provided. Operation skipped.")
+        self.report_action(tr("🌐 Opening URL '{url}' ...", url=url), ReportAction.READ)
+        try:
+            webbrowser.open(url)
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error opening URL: {url}: {err}", url=url, err=str(err))
+            )
+            return tr("Warning: Error opening URL: {url}: {err}", url=url, err=str(err))
+        self.report_success(tr("✅ URL opened in browser: {url}", url=url))
+        return tr("URL opened in browser: {url}", url=url)

janito/{tools/adapters/local → plugins/tools}/python_code_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.i18n import tr
 
 
-@register_local_tool
-class PythonCodeRunTool(ToolBase):
+@register_core_tool
+class PythonCodeRun(ToolBase):
     """
     Tool to execute Python code by passing it to the interpreter via standard input (stdin).
 
@@ -93,6 +93,9 @@ class PythonCodeRunTool(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 report_func(line.rstrip("\r\n"))
@@ -101,6 +104,11 @@ class PythonCodeRunTool(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -111,10 +119,18 @@ class PythonCodeRunTool(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        process.stdin.write(code)
-        process.stdin.close()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            process.stdin.write(code)
+            process.stdin.close()
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation or other errors
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/{tools/adapters/local → plugins/tools}/python_command_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
+from janito.plugins.tools.decorators import register_core_tool
 from janito.i18n import tr
 
 
-@register_local_tool
-class PythonCommandRunTool(ToolBase):
+@register_core_tool
+class PythonCommandRun(ToolBase):
     """
     Tool to execute Python code using the `python -c` command-line flag.
 
@@ -92,6 +92,9 @@ class PythonCommandRunTool(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 from janito.tools.tool_base import ReportAction
@@ -102,6 +105,11 @@ class PythonCommandRunTool(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -112,8 +120,16 @@ class PythonCommandRunTool(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):