janito 2.24.1__py3-none-any.whl → 2.25.0__py3-none-any.whl

janito/tools/adapters/local/fetch_url.py

@@ -43,7 +43,7 @@ class FetchUrlTool(ToolBase):
         max_lines (int, optional): Maximum number of lines to return. Defaults to 200.
         context_chars (int, optional): Characters of context around search matches. Defaults to 400.
         timeout (int, optional): Timeout in seconds for the HTTP request. Defaults to 10.
-        save_to_file (str, optional): File path to save the full resource content. If provided, 
+        save_to_file (str, optional): File path to save the full resource content. If provided,
             the complete response will be saved to this file instead of being processed.
     Returns:
         str: Extracted text content from the web page, or a warning message. Example:
@@ -60,14 +60,16 @@ class FetchUrlTool(ToolBase):
         self.cache_dir = Path.home() / ".janito" / "cache" / "fetch_url"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.cache_file = self.cache_dir / "error_cache.json"
-        self.session_cache = {}  # In-memory session cache - lifetime matches tool instance
+        self.session_cache = (
+            {}
+        )  # In-memory session cache - lifetime matches tool instance
         self._load_cache()
 
     def _load_cache(self):
         """Load error cache from disk."""
         if self.cache_file.exists():
             try:
-                with open(self.cache_file, 'r', encoding='utf-8') as f:
+                with open(self.cache_file, "r", encoding="utf-8") as f:
                     self.error_cache = json.load(f)
             except (json.JSONDecodeError, IOError):
                 self.error_cache = {}
@@ -77,7 +79,7 @@ class FetchUrlTool(ToolBase):
     def _save_cache(self):
         """Save error cache to disk."""
         try:
-            with open(self.cache_file, 'w', encoding='utf-8') as f:
+            with open(self.cache_file, "w", encoding="utf-8") as f:
                 json.dump(self.error_cache, f, indent=2)
         except IOError:
             pass  # Silently fail if we can't write cache
@@ -89,51 +91,52 @@ class FetchUrlTool(ToolBase):
         """
         if url not in self.error_cache:
             return None, False
-        
+
         entry = self.error_cache[url]
         current_time = time.time()
-        
+
         # Different expiration times for different status codes
-        if entry['status_code'] == 403:
+        if entry["status_code"] == 403:
             # Cache 403 errors for 24 hours (more permanent)
             expiration_time = 24 * 3600
-        elif entry['status_code'] == 404:
+        elif entry["status_code"] == 404:
             # Cache 404 errors for 1 hour (more temporary)
             expiration_time = 3600
         else:
             # Cache other 4xx errors for 30 minutes
             expiration_time = 1800
-            
-        if current_time - entry['timestamp'] > expiration_time:
+
+        if current_time - entry["timestamp"] > expiration_time:
             # Cache expired, remove it
             del self.error_cache[url]
             self._save_cache()
             return None, False
-            
-        return entry['message'], True
+
+        return entry["message"], True
 
     def _cache_error(self, url: str, status_code: int, message: str):
         """Cache an HTTP error response."""
         self.error_cache[url] = {
-            'status_code': status_code,
-            'message': message,
-            'timestamp': time.time()
+            "status_code": status_code,
+            "message": message,
+            "timestamp": time.time(),
         }
         self._save_cache()
 
     def _fetch_url_content(self, url: str, timeout: int = 10) -> str:
         """Fetch URL content and handle HTTP errors.
-        
+
         Implements two-tier caching:
         1. Session cache: In-memory cache for successful responses (lifetime = tool instance)
         2. Error cache: Persistent disk cache for HTTP errors with different expiration times
-        
+
         Also implements URL whitelist checking.
         """
         # Check URL whitelist
         from janito.tools.url_whitelist import get_url_whitelist_manager
+
         whitelist_manager = get_url_whitelist_manager()
-        
+
         if not whitelist_manager.is_url_allowed(url):
             error_message = tr(
                 "Warning: URL blocked by whitelist: {url}",
@@ -186,7 +189,7 @@ class FetchUrlTool(ToolBase):
                 # Cache 403 and 404 errors
                 if status_code in [403, 404]:
                     self._cache_error(url, status_code, error_message)
-                
+
                 self.report_error(
                     tr(
                         "❗ HTTP {status_code} error for URL: {url}",
@@ -262,7 +265,7 @@ class FetchUrlTool(ToolBase):
 
         return text
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="url")
     def run(
         self,
         url: str,
@@ -284,9 +287,9 @@ class FetchUrlTool(ToolBase):
             html_content = self._fetch_url_content(url, timeout=timeout)
             if html_content.startswith("Warning:"):
                 return html_content
-            
+
             try:
-                with open(save_to_file, 'w', encoding='utf-8') as f:
+                with open(save_to_file, "w", encoding="utf-8") as f:
                     f.write(html_content)
                 file_size = len(html_content)
                 self.report_success(

janito/tools/adapters/local/find_files.py

@@ -6,6 +6,7 @@ from janito.dir_walk_utils import walk_dir_with_gitignore
 from janito.i18n import tr
 import fnmatch
 import os
+from janito.tools.path_utils import expand_path
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
@@ -108,7 +109,7 @@ class FindFilesTool(ToolBase):
             }
         return sorted(dir_output)
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
     def run(
         self,
         paths: str,
@@ -121,7 +122,7 @@ class FindFilesTool(ToolBase):
             return tr("Warning: Empty file pattern provided. Operation skipped.")
         patterns = pattern.split()
         results = []
-        for directory in paths.split():
+        for directory in [expand_path(p) for p in paths.split()]:
             disp_path = display_path(directory)
             depth_msg = (
                 tr(" (max depth: {max_depth})", max_depth=max_depth)

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

@@ -4,6 +4,7 @@ from .markdown_outline import parse_markdown_outline
 from janito.formatting import OutlineFormatter
 from .java_outline import parse_java_outline
 import os
+from janito.tools.path_utils import expand_path
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.tools.tool_utils import display_path, pluralize
@@ -25,9 +26,10 @@ class GetFileOutlineTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(self, path: str) -> str:
         try:
+            path = expand_path(path)
             self.report_action(
                 tr(
                     "📄 Outline file '{disp_path}' ...",

janito/tools/adapters/local/get_file_outline/search_outline.py

@@ -16,7 +16,7 @@ class SearchOutlineTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "search_outline"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @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

janito/tools/adapters/local/move_file.py

@@ -1,4 +1,5 @@
 import os
+from janito.tools.path_utils import expand_path
 import shutil
 from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_utils import display_path
@@ -31,10 +32,10 @@ class MoveFileTool(ToolBase):
         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
-        src = src_path
-        dest = dest_path
         disp_src = display_path(original_src)
         disp_dest = display_path(original_dest)
         backup_path = None

janito/tools/adapters/local/open_html_in_browser.py

@@ -21,7 +21,7 @@ class OpenHtmlInBrowserTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "open_html_in_browser"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @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."))

janito/tools/adapters/local/open_url.py

@@ -20,7 +20,7 @@ class OpenUrlTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "open_url"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @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."))

janito/tools/adapters/local/python_file_run.py

@@ -27,6 +27,8 @@ class PythonFileRunTool(ToolBase):
     tool_name = "python_file_run"
 
     def run(self, path: str, timeout: int = 60, silent: bool = False) -> str:
+        from janito.tools.path_utils import expand_path
+        path = expand_path(path)
         if not silent:
             self.report_action(
                 tr("🚀 Running: python {path}", path=path),

janito/tools/adapters/local/read_chart.py

@@ -26,8 +26,10 @@ class ReadChartTool(ToolBase):
     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:
+    @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
@@ -36,49 +38,52 @@ class ReadChartTool(ToolBase):
             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', [])
-            
+
+            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
+                tr(
+                    "📊 Displaying {chart_type} chart: {title}",
+                    chart_type=chart_type,
+                    title=title,
+                ),
+                ReportAction.READ,
             )
-            
-            if chart_type == 'table':
+
+            if chart_type == "table":
                 return self._display_table(console, chart_data, title, width)
-            elif chart_type == 'bar':
+            elif chart_type == "bar":
                 return self._display_bar(console, chart_data, title, width, height)
-            elif chart_type == 'line':
+            elif chart_type == "line":
                 return self._display_line(console, chart_data, title, width, height)
-            elif chart_type == 'pie':
+            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
@@ -99,10 +104,10 @@ class ReadChartTool(ToolBase):
                 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:
@@ -118,10 +123,10 @@ class ReadChartTool(ToolBase):
                     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:
@@ -129,25 +134,25 @@ class ReadChartTool(ToolBase):
                     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:
@@ -165,7 +170,7 @@ class ReadChartTool(ToolBase):
                     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:
@@ -173,34 +178,34 @@ class ReadChartTool(ToolBase):
                     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:
@@ -215,7 +220,7 @@ class ReadChartTool(ToolBase):
                     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:
@@ -223,30 +228,32 @@ class ReadChartTool(ToolBase):
                     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"{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}"
+            return f"❌ Error displaying pie chart: {e}"

janito/tools/adapters/local/read_files.py

@@ -21,13 +21,14 @@ class ReadFilesTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "read_files"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @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 paths:
+        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
@@ -54,4 +55,4 @@ class ReadFilesTool(ToolBase):
                 results.append(
                     f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
                 )
-        return "\n".join(results)
+        return "\n".join(results)

janito/tools/adapters/local/remove_directory.py

@@ -6,6 +6,7 @@ from janito.i18n import tr
 import shutil
 import os
 import zipfile
+from janito.tools.path_utils import expand_path
 
 
 @register_local_tool
@@ -26,6 +27,7 @@ class RemoveDirectoryTool(ToolBase):
     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),

janito/tools/adapters/local/remove_file.py

@@ -1,4 +1,5 @@
 import os
+from janito.tools.path_utils import expand_path
 import shutil
 from janito.tools.adapters.local.adapter import register_local_tool
 
@@ -26,9 +27,8 @@ class RemoveFileTool(ToolBase):
     tool_name = "remove_file"
 
     def run(self, path: str, backup: bool = False) -> str:
-        original_path = path
-        path = path  # Using path as is
-        disp_path = display_path(original_path)
+        path = expand_path(path)
+        disp_path = display_path(path)
 
         # Report initial info about what is going to be removed
         self.report_action(

janito/tools/adapters/local/run_powershell_command.py

@@ -4,6 +4,7 @@ from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import subprocess
 import os
+from janito.tools.path_utils import expand_path
 import tempfile
 import threading
 

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

@@ -4,6 +4,7 @@ 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
@@ -153,7 +154,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)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
     def run(
         self,
         paths: str,
@@ -169,7 +170,7 @@ class SearchTextTool(ToolBase):
         )
         if error_msg:
             return error_msg
-        paths_list = paths.split()
+        paths_list = [expand_path(p) for p in paths.split()]
         results = []
         all_per_file_counts = []
         for search_path in paths_list:

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

@@ -1,4 +1,5 @@
 import os
+from janito.tools.path_utils import expand_path
 from janito.i18n import tr
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
@@ -91,8 +92,9 @@ class ValidateFileSyntaxTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "validate_file_syntax"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(self, path: str) -> str:
+        path = expand_path(path)
         disp_path = display_path(path)
         self.report_action(
             tr(

janito/tools/adapters/local/view_file.py

@@ -29,11 +29,13 @@ class ViewFileTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "view_file"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
         import os
         from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
 
+        path = expand_path(path)
         disp_path = display_path(path)
         self.report_action(
             tr("📖 View '{disp_path}'", disp_path=disp_path),