janito 2.5.1__py3-none-any.whl → 2.6.0__py3-none-any.whl

janito/tools/adapters/local/find_files.py

@@ -50,7 +50,7 @@ class FindFilesTool(ToolBase):
             dir_output.add(os.path.join(root, d))
         return dir_output
 
-    def _handle_file_path(self, directory, patterns):
+    def _handle_path(self, directory, patterns):
         dir_output = set()
         filename = os.path.basename(directory)
         for pat in patterns:
@@ -129,7 +129,7 @@ class FindFilesTool(ToolBase):
             self._report_search(pattern, disp_path, depth_msg)
             dir_output = set()
             if os.path.isfile(directory):
-                dir_output = self._handle_file_path(directory, patterns)
+                dir_output = self._handle_path(directory, patterns)
             elif os.path.isdir(directory):
                 dir_output = self._handle_directory_path(directory, patterns, max_depth, include_gitignored)
             self._report_success(len(dir_output))

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

@@ -18,22 +18,22 @@ class GetFileOutlineTool(ToolBase):
     Get an outline of a file's structure. Supports Python and Markdown files.
 
     Args:
-        file_path (str): Path to the file to outline.
+        path (str): Path to the file to outline.
     """
     permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 
-    def run(self, file_path: str) -> str:
+    def run(self, path: str) -> str:
         try:
             self.report_action(
                 tr(
                     "📄 Outline file '{disp_path}' ...",
-                    disp_path=display_path(file_path),
+                    disp_path=display_path(path),
                 ),
                 ReportAction.READ,
             )
-            ext = os.path.splitext(file_path)[1].lower()
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            ext = os.path.splitext(path)[1].lower()
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()
             return self._outline_by_extension(ext, lines)
         except Exception as e:

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

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

janito/tools/adapters/local/open_html_in_browser.py

@@ -11,29 +11,29 @@ class OpenHtmlInBrowserTool(ToolBase):
     Open the supplied HTML file in the default web browser.
 
     Args:
-        file_path (str): Path to the HTML file to open.
+        path (str): Path to the HTML file to open.
     Returns:
         str: Status message indicating the result.
     """
     permissions = ToolPermissions(read=True)
     tool_name = "open_html_in_browser"
 
-    def run(self, file_path: str) -> str:
-        if not file_path.strip():
+    def run(self, path: str) -> str:
+        if not path.strip():
             self.report_warning(tr("ℹ️ Empty file path provided."))
             return tr("Warning: Empty file path provided. Operation skipped.")
-        if not os.path.isfile(file_path):
-            self.report_error(tr("❗ File does not exist: {file_path}", file_path=file_path))
-            return tr("Warning: File does not exist: {file_path}", file_path=file_path)
-        if not file_path.lower().endswith(('.html', '.htm')):
-            self.report_warning(tr("⚠️ Not an HTML file: {file_path}", file_path=file_path))
-            return tr("Warning: Not an HTML file: {file_path}", file_path=file_path)
-        url = 'file://' + os.path.abspath(file_path)
-        self.report_action(tr("📖 Opening HTML file in browser: {file_path}", file_path=file_path), ReportAction.READ)
+        if not os.path.isfile(path):
+            self.report_error(tr("❗ File does not exist: {path}", path=path))
+            return tr("Warning: File does not exist: {path}", path=path)
+        if not path.lower().endswith(('.html', '.htm')):
+            self.report_warning(tr("⚠️ Not an HTML file: {path}", path=path))
+            return tr("Warning: Not an HTML file: {path}", path=path)
+        url = 'file://' + os.path.abspath(path)
+        self.report_action(tr("📖 Opening HTML file in browser: {path}", path=path), ReportAction.READ)
         try:
             webbrowser.open(url)
         except Exception as err:
-            self.report_error(tr("❗ Error opening HTML file: {file_path}: {err}", file_path=file_path, err=str(err)))
-            return tr("Warning: Error opening HTML file: {file_path}: {err}", file_path=file_path, err=str(err))
-        self.report_success(tr("✅ HTML file opened in browser: {file_path}", file_path=file_path))
-        return tr("HTML file opened in browser: {file_path}", file_path=file_path)
+            self.report_error(tr("❗ Error opening HTML file: {path}: {err}", path=path, err=str(err)))
+            return tr("Warning: Error opening HTML file: {path}: {err}", path=path, err=str(err))
+        self.report_success(tr("✅ HTML file opened in browser: {path}", path=path))
+        return tr("HTML file opened in browser: {path}", path=path)

janito/tools/adapters/local/python_file_run.py

@@ -15,7 +15,7 @@ class PythonFileRunTool(ToolBase):
     Tool to execute a specified Python script file.
 
     Args:
-        file_path (str): Path to the Python script file to execute.
+        path (str): Path to the Python script file to execute.
         timeout (int): Timeout in seconds for the command. Defaults to 60.
 
     Returns:
@@ -24,9 +24,9 @@ class PythonFileRunTool(ToolBase):
     permissions = ToolPermissions(execute=True)
     tool_name = "python_file_run"
 
-    def run(self, file_path: str, timeout: int = 60) -> str:
+    def run(self, path: str, timeout: int = 60) -> str:
         self.report_action(
-            tr("🚀 Running: python {file_path}", file_path=file_path),
+            tr("🚀 Running: python {path}", path=path),
             ReportAction.EXECUTE,
         )
         self.report_stdout("\n")
@@ -46,7 +46,7 @@ class PythonFileRunTool(ToolBase):
                 ) as stderr_file,
             ):
                 process = subprocess.Popen(
-                    [sys.executable, file_path],
+                    [sys.executable, path],
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
                     text=True,

janito/tools/adapters/local/read_files.py

@@ -0,0 +1,40 @@
+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
+from janito.i18n import tr
+
+@register_local_tool
+class ReadFilesTool(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"
+
+    def run(self, paths: list[str]) -> str:
+        from janito.tools.tool_utils import display_path
+        import os
+        results = []
+        for path 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/tools/adapters/local/remove_directory.py

@@ -14,7 +14,7 @@ class RemoveDirectoryTool(ToolBase):
     Remove a directory.
 
     Args:
-        file_path (str): Path to the directory to remove.
+        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:
@@ -24,8 +24,8 @@ class RemoveDirectoryTool(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "remove_directory"
 
-    def run(self, file_path: str, recursive: bool = False) -> str:
-        disp_path = display_path(file_path)
+    def run(self, path: str, recursive: bool = False) -> str:
+        disp_path = display_path(path)
         self.report_action(
             tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
             ReportAction.DELETE,
@@ -34,9 +34,9 @@ class RemoveDirectoryTool(ToolBase):
         try:
             if recursive:
 
-                shutil.rmtree(file_path)
+                shutil.rmtree(path)
             else:
-                os.rmdir(file_path)
+                os.rmdir(path)
             self.report_success(
                 tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
                 ReportAction.DELETE,

janito/tools/adapters/local/remove_file.py

@@ -14,7 +14,7 @@ class RemoveFileTool(ToolBase):
     Remove a file at the specified path.
 
     Args:
-        file_path (str): Path to the file to remove.
+        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:
@@ -24,9 +24,9 @@ class RemoveFileTool(ToolBase):
     permissions = ToolPermissions(write=True)
     tool_name = "remove_file"
 
-    def run(self, file_path: str, backup: bool = False) -> str:
-        original_path = file_path
-        path = file_path  # Using file_path as is
+    def run(self, path: str, backup: bool = False) -> str:
+        original_path = path
+        path = path  # Using path as is
         disp_path = display_path(original_path)
 
         # Report initial info about what is going to be removed

janito/tools/adapters/local/replace_text_in_file.py

@@ -17,7 +17,7 @@ class ReplaceTextInFileTool(ToolBase):
         search text in its original location.
 
     Args:
-        file_path (str): Path to the file to modify.
+        path (str): Path to the file to modify.
         search_text (str): The exact text to search for (including indentation).
         replacement_text (str): The text to replace with (including indentation).
         replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
@@ -33,7 +33,7 @@ class ReplaceTextInFileTool(ToolBase):
 
     def run(
         self,
-        file_path: str,
+        path: str,
         search_text: str,
         replacement_text: str,
         replace_all: bool = False,
@@ -41,7 +41,7 @@ class ReplaceTextInFileTool(ToolBase):
     ) -> str:
         from janito.tools.tool_utils import display_path
 
-        disp_path = display_path(file_path)
+        disp_path = display_path(path)
         action = "(all)" if replace_all else ""
         search_lines = len(search_text.splitlines())
         replace_lines = len(replacement_text.splitlines())
@@ -52,11 +52,11 @@ class ReplaceTextInFileTool(ToolBase):
             action,
             search_text,
             replacement_text,
-            file_path,
+            path,
         )
         self.report_action(info_msg, ReportAction.CREATE)
         try:
-            content = self._read_file_content(file_path)
+            content = self._read_file_content(path)
             match_lines = self._find_match_lines(content, search_text)
             occurrences = content.count(search_text)
             replaced_count, new_content = self._replace_content(
@@ -66,9 +66,9 @@ class ReplaceTextInFileTool(ToolBase):
             backup_path = None
             validation_result = ""
             if file_changed:
-                self._write_file_content(file_path, new_content)
+                self._write_file_content(path, new_content)
                 # Perform syntax validation and append result
-                validation_result = validate_file_syntax(file_path)
+                validation_result = validate_file_syntax(path)
             warning, concise_warning = self._handle_warnings(
                 replaced_count, file_changed, occurrences
             )
@@ -86,15 +86,15 @@ class ReplaceTextInFileTool(ToolBase):
                 replace_all,
             )
             return self._format_final_msg(
-                file_path, warning, match_info, details
+                path, warning, match_info, details
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
             return tr("Error replacing text: {error}", error=e)
 
-    def _read_file_content(self, file_path):
+    def _read_file_content(self, path):
         """Read the entire content of the file."""
-        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
             return f.read()
 
     def _find_match_lines(self, content, search_text):
@@ -127,13 +127,13 @@ class ReplaceTextInFileTool(ToolBase):
             new_content = content.replace(search_text, replacement_text, 1)
         return replaced_count, new_content
 
-    def _backup_file(self, file_path, backup_path):
+    def _backup_file(self, path, backup_path):
         """Create a backup of the file."""
-        shutil.copy2(file_path, backup_path)
+        shutil.copy2(path, backup_path)
 
-    def _write_file_content(self, file_path, content):
+    def _write_file_content(self, path, content):
         """Write content to the file."""
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
             f.write(content)
 
     def _handle_warnings(self, replaced_count, file_changed, occurrences):
@@ -144,14 +144,14 @@ class ReplaceTextInFileTool(ToolBase):
             warning = tr(" [Warning: Search text not found in file]")
         if not file_changed:
             self.report_warning(
-                tr(" ℹ️ No changes made. (not found)"), ReportAction.CREATE
+                tr(" ℹ️  No changes made. (not found)"), ReportAction.CREATE
             )
             concise_warning = tr(
                 "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
             )
         if occurrences > 1 and replaced_count == 0:
             self.report_warning(
-                tr(" ℹ️ No changes made. (not unique)"), ReportAction.CREATE
+                tr(" ℹ️  No changes made. (not unique)"), ReportAction.CREATE
             )
             concise_warning = tr(
                 "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
@@ -189,7 +189,7 @@ class ReplaceTextInFileTool(ToolBase):
         action,
         search_text,
         replacement_text,
-        file_path,
+        path,
     ):
         """Format the info message for the operation."""
         if replace_lines == 0:
@@ -201,7 +201,7 @@ class ReplaceTextInFileTool(ToolBase):
             )
         else:
             try:
-                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
                     _content = f.read()
                 _new_content = _content.replace(
                     search_text, replacement_text, -1 if action else 1
@@ -258,11 +258,11 @@ class ReplaceTextInFileTool(ToolBase):
             details = ""
         return match_info, details
 
-    def _format_final_msg(self, file_path, warning, match_info, details):
+    def _format_final_msg(self, path, warning, match_info, details):
         """Format the final status message."""
         return tr(
-            "Text replaced in {file_path}{warning}. {match_info}{details}",
-            file_path=file_path,
+            "Text replaced in {path}{warning}. {match_info}{details}",
+            path=path,
             warning=warning,
             match_info=match_info,
             details=details,

janito/tools/adapters/local/run_bash_command.py

@@ -48,7 +48,7 @@ class RunBashCommandTool(ToolBase):
             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),
+            tr("🖥️  Run bash command: {command} ...\n", command=command),
             ReportAction.EXECUTE,
         )
         if requires_user_input:

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

@@ -51,8 +51,8 @@ def format_result(
         lines = []
         total = 0
         if per_file_counts:
-            for file_path, count in per_file_counts:
-                lines.append(f"{file_path}: {count}")
+            for path, count in per_file_counts:
+                lines.append(f"{path}: {count}")
                 total += count
         lines.append(f"Total matches: {total}")
         if limit_reached:

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

@@ -24,7 +24,7 @@ def filter_dirs(dirs, root, gitignore_filter):
 
 
 def process_file_count_only(
-    file_path,
+    path,
     per_file_counts,
     pattern,
     regex,
@@ -34,7 +34,7 @@ def process_file_count_only(
     total_results,
 ):
     match_count, file_limit_reached, _ = read_file_lines(
-        file_path,
+        path,
         pattern,
         regex,
         use_regex,
@@ -44,12 +44,12 @@ def process_file_count_only(
         total_results + sum(count for _, count in per_file_counts),
     )
     if match_count > 0:
-        per_file_counts.append((file_path, match_count))
+        per_file_counts.append((path, match_count))
     return file_limit_reached
 
 
 def process_file_collect(
-    file_path,
+    path,
     dir_output,
     per_file_counts,
     pattern,
@@ -60,7 +60,7 @@ def process_file_collect(
     total_results,
 ):
     actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
-        file_path,
+        path,
         pattern,
         regex,
         use_regex,
@@ -71,7 +71,7 @@ def process_file_collect(
     )
     dir_output.extend(file_lines_output)
     if actual_match_count > 0:
-        per_file_counts.append((file_path, actual_match_count))
+        per_file_counts.append((path, actual_match_count))
     return file_limit_reached
 
 
@@ -104,12 +104,12 @@ def traverse_directory(
     for root, dirs, files in walker:
         dirs[:] = filter_dirs(dirs, root, gitignore_filter)
         for file in files:
-            file_path = os.path.join(root, file)
-            if gitignore_filter.is_ignored(file_path):
+            path = os.path.join(root, file)
+            if gitignore_filter.is_ignored(path):
                 continue
             if count_only:
                 file_limit_reached = process_file_count_only(
-                    file_path,
+                    path,
                     per_file_counts,
                     pattern,
                     regex,
@@ -123,7 +123,7 @@ def traverse_directory(
                     break
             else:
                 file_limit_reached = process_file_collect(
-                    file_path,
+                    path,
                     dir_output,
                     per_file_counts,
                     pattern,

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

@@ -44,13 +44,13 @@ def _handle_validation_error(e, report_warning):
 
 
 def validate_file_syntax(
-    file_path: str, report_info=None, report_warning=None, report_success=None
+    path: str, report_info=None, report_warning=None, report_success=None
 ) -> str:
-    ext = os.path.splitext(file_path)[1].lower()
+    ext = os.path.splitext(path)[1].lower()
     validator = _get_validator(ext)
     try:
         if validator:
-            return validator(file_path)
+            return validator(path)
         else:
             msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
             if report_warning:
@@ -75,7 +75,7 @@ class ValidateFileSyntaxTool(ToolBase):
       - JavaScript (.js)
 
     Args:
-        file_path (str): Path to the file to validate.
+        path (str): Path to the file to validate.
     Returns:
         str: Validation status message. Example:
             - "✅ Syntax OK"
@@ -85,8 +85,8 @@ class ValidateFileSyntaxTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "validate_file_syntax"
 
-    def run(self, file_path: str) -> str:
-        disp_path = display_path(file_path)
+    def run(self, path: str) -> str:
+        disp_path = display_path(path)
         self.report_action(
             tr(
                 "🔎 Validate syntax for file '{disp_path}' ...",
@@ -95,7 +95,7 @@ class ValidateFileSyntaxTool(ToolBase):
             ReportAction.READ,
         )
         result = validate_file_syntax(
-            file_path,
+            path,
             
             report_warning=self.report_warning,
             report_success=self.report_success,

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

@@ -2,8 +2,8 @@ from janito.i18n import tr
 import re
 
 
-def validate_css(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8") as f:
+def validate_css(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
         content = f.read()
     errors = []
     # Check for unmatched curly braces

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

@@ -3,16 +3,16 @@ import re
 from lxml import etree
 
 
-def validate_html(file_path: str) -> str:
-    html_content = _read_html_content(file_path)
+def validate_html(path: str) -> str:
+    html_content = _read_html_content(path)
     warnings = _find_js_outside_script(html_content)
-    lxml_error = _parse_html_and_collect_errors(file_path)
+    lxml_error = _parse_html_and_collect_errors(path)
     msg = _build_result_message(warnings, lxml_error)
     return msg
 
 
-def _read_html_content(file_path):
-    with open(file_path, "r", encoding="utf-8") as f:
+def _read_html_content(path):
+    with open(path, "r", encoding="utf-8") as f:
         return f.read()
 
 
@@ -46,11 +46,11 @@ def _find_js_outside_script(html_content):
     return warnings
 
 
-def _parse_html_and_collect_errors(file_path):
+def _parse_html_and_collect_errors(path):
     lxml_error = None
     try:
         parser = etree.HTMLParser(recover=False)
-        with open(file_path, "rb") as f:
+        with open(path, "rb") as f:
             etree.parse(f, parser=parser)
         error_log = parser.error_log
         syntax_errors = []

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

@@ -2,8 +2,8 @@ from janito.i18n import tr
 import re
 
 
-def validate_js(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8") as f:
+def validate_js(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
         content = f.read()
     errors = []
     if content.count("{") != content.count("}"):

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

@@ -1,6 +1,6 @@
-def validate_json(file_path: str) -> str:
+def validate_json(path: str) -> str:
     import json
 
-    with open(file_path, "r", encoding="utf-8") as f:
+    with open(path, "r", encoding="utf-8") as f:
         json.load(f)
     return "✅ OK"

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

@@ -2,8 +2,8 @@ from janito.i18n import tr
 import re
 
 
-def validate_markdown(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8") as f:
+def validate_markdown(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
         content = f.read()
     lines = content.splitlines()
     errors = []

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

@@ -2,8 +2,8 @@ from janito.i18n import tr
 import re
 
 
-def validate_ps1(file_path: str) -> str:
-    with open(file_path, "r", encoding="utf-8") as f:
+def validate_ps1(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
         content = f.read()
     errors = []
     # Unmatched curly braces

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

@@ -1,5 +1,5 @@
-def validate_python(file_path: str) -> str:
+def validate_python(path: str) -> str:
     import py_compile
 
-    py_compile.compile(file_path, doraise=True)
+    py_compile.compile(path, doraise=True)
     return "✅ OK"

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

@@ -1,11 +1,11 @@
 from janito.i18n import tr
 
 
-def validate_xml(file_path: str) -> str:
+def validate_xml(path: str) -> str:
     try:
         from lxml import etree
     except ImportError:
         return tr("⚠️ lxml not installed. Cannot validate XML.")
-    with open(file_path, "rb") as f:
+    with open(path, "rb") as f:
         etree.parse(f)
     return "✅ OK"