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

janito/{tools/adapters/local → plugins/tools}/python_file_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 PythonFileRunTool(ToolBase):
+@register_core_tool
+class PythonFileRun(ToolBase):
     """
     Tool to execute a specified Python script file.
 
@@ -92,6 +92,9 @@ class PythonFileRunTool(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()
                 # Always supply a default action for stdout/stderr reporting
@@ -103,6 +106,11 @@ class PythonFileRunTool(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"),
@@ -113,8 +121,16 @@ class PythonFileRunTool(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("File execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/plugins/tools/read_chart.py

@@ -0,0 +1,259 @@
+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 display_path
+from janito.i18n import tr
+import json
+import os
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_core_tool
+class ReadChart(ToolBase):
+    """
+    Display charts and data visualizations in the terminal using rich.
+
+    Args:
+        data (dict): Chart data in JSON format. Should contain 'type' (bar, line, pie, table) and 'data' keys.
+        title (str, optional): Chart title. Defaults to "Chart".
+        width (int, optional): Chart width. Defaults to 80.
+        height (int, optional): Chart height. Defaults to 20.
+
+    Returns:
+        str: Formatted chart display in terminal or error message.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "read_chart"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="data")
+    def run(
+        self, data: dict, title: str = "Chart", width: int = 80, height: int = 20
+    ) -> str:
+        try:
+            from rich.console import Console
+            from rich.table import Table
+            from rich.text import Text
+            from rich.layout import Layout
+            from rich.panel import Panel
+            from rich.columns import Columns
+            from rich import box
+
+            console = Console(width=width)
+
+            if not isinstance(data, dict):
+                return "❌ Error: Data must be a dictionary"
+
+            chart_type = data.get("type", "table").lower()
+            chart_data = data.get("data", [])
+
+            if not chart_data:
+                return "⚠️ Warning: No data provided for chart"
+
+            self.report_action(
+                tr(
+                    "📊 Displaying {chart_type} chart: {title}",
+                    chart_type=chart_type,
+                    title=title,
+                ),
+                ReportAction.READ,
+            )
+
+            if chart_type == "table":
+                return self._display_table(console, chart_data, title, width)
+            elif chart_type == "bar":
+                return self._display_bar(console, chart_data, title, width, height)
+            elif chart_type == "line":
+                return self._display_line(console, chart_data, title, width, height)
+            elif chart_type == "pie":
+                return self._display_pie(console, chart_data, title, width)
+            else:
+                return f"❌ Error: Unsupported chart type '{chart_type}'. Use: table, bar, line, pie"
+
+        except ImportError:
+            return "❌ Error: rich library not available for chart display"
+        except Exception as e:
+            return f"❌ Error displaying chart: {e}"
+
+    def _display_table(self, console, data, title, width):
+        """Display data as a rich table."""
+        from rich.table import Table
+
+        if not data:
+            return "No data to display"
+
+        table = Table(title=title, show_header=True, header_style="bold magenta")
+
+        # Handle different data formats
+        if isinstance(data, dict):
+            # Dictionary format: key-value pairs
+            table.add_column("Key", style="cyan")
+            table.add_column("Value", style="green")
+            for key, value in data.items():
+                table.add_row(str(key), str(value))
+        elif isinstance(data, list):
+            if data and isinstance(data[0], dict):
+                # List of dictionaries (records)
+                headers = list(data[0].keys()) if data else []
+                for header in headers:
+                    table.add_column(str(header).title(), style="cyan")
+                for row in data:
+                    table.add_row(*[str(row.get(h, "")) for h in headers])
+            else:
+                # Simple list
+                table.add_column("Items", style="cyan")
+                for item in data:
+                    table.add_row(str(item))
+
+        console.print(table)
+        return f"✅ Table chart displayed: {title}"
+
+    def _display_bar(self, console, data, title, width, height):
+        """Display data as a simple bar chart using unicode blocks."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list) and data and isinstance(data[0], dict):
+                # Assume first two keys are labels and values
+                keys = list(data[0].keys())
+                if len(keys) >= 2:
+                    label_key, value_key = keys[0], keys[1]
+                    items = [(item[label_key], item[value_key]) for item in data]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                items = [(str(i), v) for i, v in enumerate(data)]
+
+            if not items:
+                return "No data to display"
+
+            # Convert values to numbers
+            numeric_items = []
+            for label, value in items:
+                try:
+                    numeric_items.append((str(label), float(value)))
+                except (ValueError, TypeError):
+                    numeric_items.append((str(label), 0.0))
+
+            if not numeric_items:
+                return "No valid numeric data to display"
+
+            max_val = max(val for _, val in numeric_items) if numeric_items else 1
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            for label, value in numeric_items:
+                bar_length = int((value / max_val) * (width - 20)) if max_val > 0 else 0
+                bar = "█" * bar_length
+                console.print(f"{label:<15} {bar} {value:.1f}")
+
+            return f"✅ Bar chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying bar chart: {e}"
+
+    def _display_line(self, console, data, title, width, height):
+        """Display data as a simple line chart using unicode characters."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list):
+                if data and isinstance(data[0], dict):
+                    keys = list(data[0].keys())
+                    if len(keys) >= 2:
+                        label_key, value_key = keys[0], keys[1]
+                        items = [(item[label_key], item[value_key]) for item in data]
+                    else:
+                        items = [(str(i), v) for i, v in enumerate(data)]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                return "Unsupported data format"
+
+            # Convert to numeric values
+            points = []
+            for x, y in items:
+                try:
+                    points.append((float(x), float(y)))
+                except (ValueError, TypeError):
+                    continue
+
+            if len(points) < 2:
+                return "Need at least 2 data points for line chart"
+
+            points.sort(key=lambda p: p[0])
+
+            # Simple ASCII line chart
+            min_x, max_x = min(p[0] for p in points), max(p[0] for p in points)
+            min_y, max_y = min(p[1] for p in points), max(p[1] for p in points)
+
+            if max_x == min_x or max_y == min_y:
+                return "Cannot display line chart: all values are the same"
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            # Simple representation
+            for x, y in points:
+                x_norm = int(((x - min_x) / (max_x - min_x)) * (width - 20))
+                y_norm = int(((y - min_y) / (max_y - min_y)) * 10)
+                line = " " * x_norm + "●" + " " * (width - 20 - x_norm)
+                console.print(f"{x:>8.1f}: {line} {y:.1f}")
+
+            return f"✅ Line chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying line chart: {e}"
+
+    def _display_pie(self, console, data, title, width):
+        """Display data as a simple pie chart representation."""
+        try:
+            if isinstance(data, dict):
+                items = list(data.items())
+            elif isinstance(data, list) and data and isinstance(data[0], dict):
+                keys = list(data[0].keys())
+                if len(keys) >= 2:
+                    label_key, value_key = keys[0], keys[1]
+                    items = [(item[label_key], item[value_key]) for item in data]
+                else:
+                    items = [(str(i), v) for i, v in enumerate(data)]
+            else:
+                items = [(str(i), v) for i, v in enumerate(data)]
+
+            # Convert to numeric values
+            values = []
+            for label, value in items:
+                try:
+                    values.append((str(label), float(value)))
+                except (ValueError, TypeError):
+                    continue
+
+            if not values:
+                return "No valid numeric data to display"
+
+            total = sum(val for _, val in values)
+            if total == 0:
+                return "Cannot display pie chart: total is zero"
+
+            console.print(f"\n[bold]{title}[/bold]")
+            console.print("=" * min(len(title), width))
+
+            # Unicode pie chart segments
+            segments = ["🟦", "🟥", "🟩", "🟨", "🟪", "🟧", "⬛", "⬜"]
+
+            for i, (label, value) in enumerate(values):
+                percentage = (value / total) * 100
+                segment = segments[i % len(segments)]
+                bar_length = int((value / total) * (width - 30))
+                bar = "█" * bar_length
+                console.print(
+                    f"{segment} {label:<15} {bar} {percentage:5.1f}% ({value})"
+                )
+
+            console.print(f"\n[dim]Total: {total}[/dim]")
+
+            return f"✅ Pie chart displayed: {title}"
+
+        except Exception as e:
+            return f"❌ Error displaying pie chart: {e}"

janito/plugins/tools/read_files.py

@@ -0,0 +1,58 @@
+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 ReadFiles(ToolBase):
+    """
+    Read all text content from multiple files.
+
+    Args:
+        paths (list[str]): List of file paths to read.
+
+    Returns:
+        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "read_files"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(self, paths: list[str]) -> str:
+        from janito.tools.tool_utils import display_path
+        import os
+        from janito.tools.path_utils import expand_path
+
+        results = []
+        for path in [expand_path(p) for p in paths]:
+            disp_path = display_path(path)
+            self.report_action(
+                tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ
+            )
+            if not os.path.isfile(path):
+                self.report_warning(
+                    tr("❗ not found: {disp_path}", disp_path=disp_path)
+                )
+                results.append(f"--- File: {disp_path} (not found) ---\n")
+                continue
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read()
+                results.append(f"--- File: {disp_path} ---\n{content}\n")
+                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
+            except Exception as e:
+                self.report_error(
+                    tr(
+                        " ❌ Error reading {disp_path}: {error}",
+                        disp_path=disp_path,
+                        error=e,
+                    )
+                )
+                results.append(
+                    f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
+                )
+        return "\n".join(results)

janito/plugins/tools/remove_directory.py

@@ -0,0 +1,55 @@
+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, display_path
+from janito.i18n import tr
+import shutil
+import os
+import zipfile
+from janito.tools.path_utils import expand_path
+
+
+@register_core_tool
+class RemoveDirectory(ToolBase):
+    """
+    Remove a directory.
+
+    Args:
+        path (str): Path to the directory to remove.
+        recursive (bool, optional): If True, remove non-empty directories recursively (with backup). If False, only remove empty directories. Defaults to False.
+    Returns:
+        str: Status message indicating result. Example:
+            - "Directory removed: /path/to/dir"
+            - "Error removing directory: <error message>"
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "remove_directory"
+
+    def run(self, path: str, recursive: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.DELETE,
+        )
+
+        try:
+            if recursive:
+
+                shutil.rmtree(path)
+            else:
+                os.rmdir(path)
+            self.report_success(
+                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
+                ReportAction.DELETE,
+            )
+            msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
+
+            return msg
+        except Exception as e:
+            self.report_error(
+                tr(" ❌ Error removing directory: {error}", error=e),
+                ReportAction.DELETE,
+            )
+            return tr("Error removing directory: {error}", error=e)

janito/plugins/tools/remove_file.py

@@ -0,0 +1,58 @@
+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 RemoveFile(ToolBase):
+    """
+    Remove a file at the specified path.
+
+    Args:
+        path (str): Path to the file to remove.
+        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "			 Successfully removed the file at ..."
+            - "			 Cannot remove file: ..."
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "remove_file"
+
+    def run(self, path: str, backup: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+
+        # Report initial info about what is going to be removed
+        self.report_action(
+            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.DELETE,
+        )
+        if not os.path.exists(path):
+            self.report_error(tr("❌ File does not exist."), ReportAction.DELETE)
+            return tr("❌ File does not exist.")
+        if not os.path.isfile(path):
+            self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
+            return tr("❌ Path is not a file.")
+        try:
+
+            os.remove(path)
+            self.report_success(tr("✅ File removed"), ReportAction.DELETE)
+            msg = tr(
+                "✅ Successfully removed the file at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+
+            return msg
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error removing file: {error}", error=e), ReportAction.DELETE
+            )
+            return tr("❌ Error removing file: {error}", error=e)

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

@@ -1,14 +1,14 @@
 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
 import shutil
 import re
-from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
+from janito.plugins.tools.validate_file_syntax.core import validate_file_syntax
 
 
-@register_local_tool
-class ReplaceTextInFileTool(ToolBase):
+@register_core_tool
+class ReplaceTextInFile(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
 

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

@@ -1,6 +1,6 @@
 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
 import subprocess
 import tempfile
@@ -9,8 +9,8 @@ import os
 import threading
 
 
-@register_local_tool
-class RunBashCommandTool(ToolBase):
+@register_core_tool
+class RunBashCommand(ToolBase):
     """
     Execute a non-interactive command using the bash shell and capture live output.
     This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).

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

@@ -1,6 +1,6 @@
 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
 import subprocess
 import os
@@ -9,8 +9,8 @@ import tempfile
 import threading
 
 
-@register_local_tool
-class RunPowershellCommandTool(ToolBase):
+@register_core_tool
+class RunPowershellCommand(ToolBase):
     """
     Execute a non-interactive command using the PowerShell shell and capture live output.
     This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).

janito/plugins/tools/search_text/__init__.py

@@ -0,0 +1,7 @@
+"""
+Text search tools for janito.
+"""
+
+from .core import SearchText
+
+__all__ = ["SearchText"]