janito 2.22.0__py3-none-any.whl → 2.24.0__py3-none-any.whl

janito/tools/adapters/local/read_chart.py

@@ -0,0 +1,252 @@
+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 display_path
+from janito.i18n import tr
+import json
+import os
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ReadChartTool(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)
+    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/tools/adapters/local/read_files.py

@@ -3,6 +3,7 @@ from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_utils import pluralize
 from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -20,6 +21,7 @@ class ReadFilesTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "read_files"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, paths: list[str]) -> str:
         from janito.tools.tool_utils import display_path
         import os

janito/tools/adapters/local/replace_text_in_file.py

@@ -90,7 +90,7 @@ class ReplaceTextInFileTool(ToolBase):
                 f"\n{validation_result}" if validation_result else ""
             )
         except Exception as e:
-            self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
+            self.report_error(tr(" ❌ Error"), ReportAction.UPDATE)
             return tr("Error replacing text: {error}", error=e)
 
     def _read_file_content(self, path):

janito/tools/adapters/local/run_bash_command.py

@@ -20,6 +20,7 @@ class RunBashCommandTool(ToolBase):
         timeout (int): Timeout in seconds for the command. Defaults to 60.
         require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
         requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
 
     Returns:
         str: File paths and line counts for stdout and stderr.
@@ -44,15 +45,19 @@ class RunBashCommandTool(ToolBase):
         timeout: int = 60,
         require_confirmation: bool = False,
         requires_user_input: bool = False,
+        silent: bool = False,
     ) -> str:
         if not command.strip():
             self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
             return tr("Warning: Empty command provided. Operation skipped.")
-        self.report_action(
-            tr("🖥️  Run bash command: {command} ...\n", command=command),
-            ReportAction.EXECUTE,
-        )
-        if requires_user_input:
+        if not silent:
+            self.report_action(
+                tr("🖥️  Run bash command: {command} ...\n", command=command),
+                ReportAction.EXECUTE,
+            )
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
+        if requires_user_input and not silent:
             self.report_warning(
                 tr(
                     "⚠️  Warning: This command might be interactive, require user input, and might hang."
@@ -123,13 +128,14 @@ class RunBashCommandTool(ToolBase):
                 stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-                self.report_success(
-                    tr(
-                        " ✅ return code {return_code}",
-                        return_code=return_code,
-                    ),
-                    ReportAction.EXECUTE,
-                )
+                if not silent:
+                    self.report_success(
+                        tr(
+                            " ✅ return code {return_code}",
+                            return_code=return_code,
+                        ),
+                        ReportAction.EXECUTE,
+                    )
                 max_lines = 100
                 # Read back the output for summary
                 stdout_file.seek(0)

janito/tools/adapters/local/run_powershell_command.py

@@ -22,6 +22,7 @@ class RunPowershellCommandTool(ToolBase):
         timeout (int): Timeout in seconds for the command. Defaults to 60.
         require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
         requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+        silent (bool): If True, suppresses progress and status messages. Defaults to False.
 
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
@@ -41,7 +42,7 @@ class RunPowershellCommandTool(ToolBase):
         if require_confirmation:
             self.report_warning(
                 tr("⚠️ Confirmation requested, but no handler (auto-confirmed)."),
-                ReportAction.USER_INPUT
+                ReportAction.EXECUTE
             )
             return True  # Auto-confirm for now
         return True
@@ -127,16 +128,20 @@ class RunPowershellCommandTool(ToolBase):
         timeout: int = 60,
         require_confirmation: bool = False,
         requires_user_input: bool = False,
+        silent: bool = False,
     ) -> str:
         if not command.strip():
             self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
             return tr("Warning: Empty command provided. Operation skipped.")
         encoding_prefix = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
         command_with_encoding = encoding_prefix + command
-        self.report_action(
-            tr("🖥️ Running PowerShell command: {command} ...\n", command=command),
-            ReportAction.EXECUTE,
-        )
+        if not silent:
+            self.report_action(
+                tr("🖥️ Running PowerShell command: {command} ...\n", command=command),
+                ReportAction.EXECUTE,
+            )
+        else:
+            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
         self._confirm_and_warn(command, require_confirmation, requires_user_input)
         from janito.platform_discovery import PlatformDiscovery
 
@@ -199,10 +204,11 @@ class RunPowershellCommandTool(ToolBase):
                 stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-                self.report_success(
-                    tr(" ✅ return code {return_code}", return_code=return_code),
-                    ReportAction.EXECUTE,
-                )
+                if not silent:
+                    self.report_success(
+                        tr(" ✅ return code {return_code}", return_code=return_code),
+                        ReportAction.EXECUTE,
+                    )
                 return self._format_result(
                     requires_user_input, return_code, stdout_file, stderr_file
                 )

janito/tools/adapters/local/search_text/core.py

@@ -7,6 +7,7 @@ import os
 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.tools.adapters.local.adapter import register_local_tool as register_tool
@@ -152,6 +153,7 @@ class SearchTextTool(ToolBase):
         )
         return info_str, dir_output, dir_limit_reached, per_file_counts
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(
         self,
         paths: str,

janito/tools/adapters/local/validate_file_syntax/core.py

@@ -15,6 +15,8 @@ from .html_validator import validate_html
 from .markdown_validator import validate_markdown
 from .js_validator import validate_js
 from .css_validator import validate_css
+from .jinja2_validator import validate_jinja2
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 def _get_validator(ext):
@@ -32,6 +34,8 @@ def _get_validator(ext):
         ".md": validate_markdown,
         ".js": validate_js,
         ".css": validate_css,
+        ".j2": validate_jinja2,
+        ".jinja2": validate_jinja2,
     }
     return mapping.get(ext)
 
@@ -73,6 +77,7 @@ class ValidateFileSyntaxTool(ToolBase):
       - HTML (.html, .htm) [lxml]
       - Markdown (.md)
       - JavaScript (.js)
+      - Jinja2 templates (.j2, .jinja2)
 
     Args:
         path (str): Path to the file to validate.
@@ -86,6 +91,7 @@ class ValidateFileSyntaxTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "validate_file_syntax"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, path: str) -> str:
         disp_path = display_path(path)
         self.report_action(

janito/tools/adapters/local/validate_file_syntax/jinja2_validator.py

@@ -0,0 +1,47 @@
+"""Jinja2 template syntax validator."""
+
+import os
+from janito.i18n import tr
+
+
+def validate_jinja2(path: str) -> str:
+    """Validate Jinja2 template syntax."""
+    try:
+        from jinja2 import Environment, TemplateSyntaxError
+        
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+        
+        # Create a Jinja2 environment and try to parse the template
+        env = Environment()
+        try:
+            env.parse(content)
+            return tr("✅ Syntax OK")
+        except TemplateSyntaxError as e:
+            line_num = getattr(e, 'lineno', 0)
+            return tr("⚠️ Warning: Syntax error: {error} at line {line}", 
+                     error=str(e), line=line_num)
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))
+            
+    except ImportError:
+        # If jinja2 is not available, just check basic structure
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+            
+            # Basic checks for common Jinja2 syntax issues
+            open_tags = content.count("{%")
+            close_tags = content.count("%}")
+            open_vars = content.count("{{")
+            close_vars = content.count("}}")
+            
+            if open_tags != close_tags:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 tags")
+            if open_vars != close_vars:
+                return tr("⚠️ Warning: Syntax error: Mismatched Jinja2 variables")
+                
+            return tr("✅ Syntax OK (basic validation)")
+            
+        except Exception as e:
+            return tr("⚠️ Warning: Syntax error: {error}", error=str(e))

janito/tools/adapters/local/view_file.py

@@ -3,6 +3,7 @@ from janito.report_events import ReportAction
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_utils import pluralize
 from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 
 @register_local_tool
@@ -28,6 +29,7 @@ class ViewFileTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "view_file"
 
+    @protect_against_loops(max_calls=5, time_window=10.0)
     def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
         import os
         from janito.tools.tool_utils import display_path

janito/tools/loop_protection.py

@@ -0,0 +1,115 @@
+import time
+import threading
+from typing import Dict, List, Tuple
+from janito.tools.tool_use_tracker import normalize_path
+
+
+class LoopProtection:
+    """
+    Provides loop protection for tool calls by tracking repeated operations
+    on the same resources within a short time period.
+    
+    This class monitors file operations and prevents excessive reads on the same
+    file within a configurable time window. It helps prevent infinite loops or
+    excessive resource consumption when tools repeatedly access the same files.
+    
+    The default configuration allows up to 5 operations on the same file within
+    a 10-second window. Operations outside this window are automatically cleaned
+    up to prevent memory accumulation.
+    """
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._init_protection()
+        return cls._instance
+    
+    def _init_protection(self):
+        # Track file operations: {normalized_path: [(timestamp, operation_type), ...]}
+        self._file_operations: Dict[str, List[Tuple[float, str]]] = {}
+        # Time window for detecting loops (in seconds)
+        self._time_window = 10.0
+        # Maximum allowed operations on the same file within time window
+        self._max_operations = 5
+        
+        """
+        Configuration parameters:
+        
+        _time_window: Time window in seconds for detecting excessive operations.
+                     Default is 10.0 seconds.
+                     
+        _max_operations: Maximum number of operations allowed on the same file
+                        within the time window. Default is 5 operations.
+        """
+        
+    def check_file_operation_limit(self, path: str, operation_type: str) -> bool:
+        """
+        Check if performing an operation on a file would exceed the limit.
+        
+        This method tracks file operations and prevents excessive reads on the same
+        file within a configurable time window (default 10 seconds). It helps prevent
+        infinite loops or excessive resource consumption when tools repeatedly access
+        the same files.
+        
+        Args:
+            path: The file path being operated on
+            operation_type: Type of operation (e.g., "view_file", "read_files")
+            
+        Returns:
+            bool: True if operation is allowed, False if it would exceed the limit
+            
+        Example:
+            >>> loop_protection = LoopProtection.instance()
+            >>> if loop_protection.check_file_operation_limit("/path/to/file.txt", "view_file"):
+            ...     # Safe to proceed with file operation
+            ...     content = read_file("/path/to/file.txt")
+            ... else:
+            ...     # Would exceed limit - potential loop detected
+            ...     raise RuntimeError("Too many operations on the same file")
+        """
+        norm_path = normalize_path(path)
+        current_time = time.time()
+        
+        # Clean up old operations outside the time window
+        if norm_path in self._file_operations:
+            self._file_operations[norm_path] = [
+                (timestamp, op_type) 
+                for timestamp, op_type in self._file_operations[norm_path]
+                if current_time - timestamp <= self._time_window
+            ]
+        
+        # Check if we're exceeding the limit
+        if norm_path in self._file_operations:
+            operations = self._file_operations[norm_path]
+            if len(operations) >= self._max_operations:
+                # Check if all recent operations are within the time window
+                if all(current_time - timestamp <= self._time_window 
+                      for timestamp, _ in operations):
+                    return False  # Would exceed limit - potential loop
+        
+        # Record this operation
+        if norm_path not in self._file_operations:
+            self._file_operations[norm_path] = []
+        self._file_operations[norm_path].append((current_time, operation_type))
+        
+        return True  # Operation allowed
+    
+    def reset_tracking(self):
+        """
+        Reset all tracking data.
+        
+        This method clears all recorded file operations, effectively resetting
+        the loop protection state. This can be useful in testing scenarios or
+        when you want to explicitly clear the tracking history.
+        """
+        with self._lock:
+            self._file_operations.clear()
+    
+    @classmethod
+    def instance(cls):
+        return cls()