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

janito/plugins/tools/read_chart.py

@@ -1,259 +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 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

@@ -1,58 +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 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

@@ -1,55 +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, 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

@@ -1,58 +0,0 @@
-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/plugins/tools/search_text/__init__.py

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

janito/plugins/tools/search_text/core.py

@@ -1,205 +0,0 @@
-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.tools.tool_utils import pluralize, display_path
-from janito.i18n import tr
-import os
-from janito.tools.path_utils import expand_path
-from .pattern_utils import prepare_pattern, format_result, summarize_total
-from .match_lines import read_file_lines
-from .traverse_directory import traverse_directory
-from janito.tools.loop_protection_decorator import protect_against_loops
-
-
-from janito.plugins.tools.decorators import register_core_tool
-
-
-@register_core_tool
-class SearchText(ToolBase):
-    """
-    Search for a text query in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
-    Args:
-        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
-        query (str): Text or regular expression to search for in files. Must not be empty. When use_regex=True, this is treated as a regex pattern; otherwise as plain text.
-        use_regex (bool): If True, treat query as a regular expression. If False, treat as plain text (default).
-        case_sensitive (bool): If False, perform a case-insensitive search. Default is True (case sensitive).
-        max_depth (int, optional): Maximum directory depth to search. If 0 (default), search is recursive with no depth limit. If >0, limits recursion to that depth. Setting max_depth=1 disables recursion (only top-level directory). Ignored for file paths.
-        max_results (int, optional): Maximum number of results to return. Defaults to 100. 0 means no limit.
-        count_only (bool): If True, return only the count of matches per file and total, not the matching lines. Default is False.
-    Returns:
-        str: If count_only is False, matching lines from files as a newline-separated string, each formatted as 'filepath:lineno: line'.
-             If count_only is True, returns per-file and total match counts.
-        If max_results is reached, appends a note to the output.
-    """
-
-    permissions = ToolPermissions(read=True)
-    tool_name = "search_text"
-
-    def _handle_file(
-        self,
-        search_path,
-        query,
-        regex,
-        use_regex,
-        case_sensitive,
-        max_results,
-        total_results,
-        count_only,
-    ):
-        if count_only:
-            match_count, dir_limit_reached, _ = read_file_lines(
-                search_path,
-                query,
-                regex,
-                use_regex,
-                case_sensitive,
-                True,
-                max_results,
-                total_results,
-            )
-            per_file_counts = [(search_path, match_count)] if match_count > 0 else []
-            return [], dir_limit_reached, per_file_counts
-        else:
-            dir_output, dir_limit_reached, match_count_list = read_file_lines(
-                search_path,
-                query,
-                regex,
-                use_regex,
-                case_sensitive,
-                False,
-                max_results,
-                total_results,
-            )
-            per_file_counts = (
-                [(search_path, len(match_count_list))]
-                if match_count_list and len(match_count_list) > 0
-                else []
-            )
-            return dir_output, dir_limit_reached, per_file_counts
-
-    def _handle_path(
-        self,
-        search_path,
-        query,
-        regex,
-        use_regex,
-        case_sensitive,
-        max_depth,
-        max_results,
-        total_results,
-        count_only,
-    ):
-        info_str = tr(
-            "🔍 Search {search_type} '{query}' in '{disp_path}'",
-            search_type=("regex" if use_regex else "text"),
-            query=query,
-            disp_path=display_path(search_path),
-        )
-        if max_depth > 0:
-            info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
-        if count_only:
-            info_str += " [count]"
-        self.report_action(info_str, ReportAction.READ)
-        if os.path.isfile(search_path):
-            dir_output, dir_limit_reached, per_file_counts = self._handle_file(
-                search_path,
-                query,
-                regex,
-                use_regex,
-                case_sensitive,
-                max_results,
-                total_results,
-                count_only,
-            )
-        else:
-            if count_only:
-                per_file_counts, dir_limit_reached, _ = traverse_directory(
-                    search_path,
-                    query,
-                    regex,
-                    use_regex,
-                    case_sensitive,
-                    max_depth,
-                    max_results,
-                    total_results,
-                    True,
-                )
-                dir_output = []
-            else:
-                dir_output, dir_limit_reached, per_file_counts = traverse_directory(
-                    search_path,
-                    query,
-                    regex,
-                    use_regex,
-                    case_sensitive,
-                    max_depth,
-                    max_results,
-                    total_results,
-                    False,
-                )
-        count = sum(count for _, count in per_file_counts)
-        file_word = pluralize("match", count)
-        num_files = len(per_file_counts)
-        file_label = pluralize("file", num_files)
-        file_word_max = file_word + (" (max)" if dir_limit_reached else "")
-        self.report_success(
-            tr(
-                " ✅ {count} {file_word}/{num_files} {file_label}",
-                count=count,
-                file_word=file_word_max,
-                num_files=num_files,
-                file_label=file_label,
-            ),
-            ReportAction.READ,
-        )
-        return info_str, dir_output, dir_limit_reached, per_file_counts
-
-    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
-    def run(
-        self,
-        paths: str,
-        query: str,
-        use_regex: bool = False,
-        case_sensitive: bool = False,
-        max_depth: int = 0,
-        max_results: int = 100,
-        count_only: bool = False,
-    ) -> str:
-        regex, use_regex, error_msg = prepare_pattern(
-            query, use_regex, case_sensitive, self.report_error, self.report_warning
-        )
-        if error_msg:
-            return error_msg
-        paths_list = [expand_path(p) for p in paths.split()]
-        results = []
-        all_per_file_counts = []
-        for search_path in paths_list:
-            info_str, dir_output, dir_limit_reached, per_file_counts = (
-                self._handle_path(
-                    search_path,
-                    query,
-                    regex,
-                    use_regex,
-                    case_sensitive,
-                    max_depth,
-                    max_results,
-                    0,
-                    count_only,
-                )
-            )
-            if count_only:
-                all_per_file_counts.extend(per_file_counts)
-            result_str = format_result(
-                query,
-                use_regex,
-                dir_output,
-                dir_limit_reached,
-                count_only,
-                per_file_counts,
-            )
-            results.append(info_str + "\n" + result_str)
-            if dir_limit_reached:
-                break
-        if count_only:
-            results.append(summarize_total(all_per_file_counts))
-        return "\n\n".join(results)