janito 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

janito/agent/tools/move_file.py

@@ -1,7 +1,9 @@
 import os
 import shutil
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.utils import expand_path, display_path
+
+# from janito.agent.tools_utils.expand_path import expand_path
+from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
 from janito.i18n import tr
 
@@ -29,8 +31,8 @@ class MoveFileTool(ToolBase):
     ) -> str:
         original_src = src_path
         original_dest = dest_path
-        src = expand_path(src_path)
-        dest = expand_path(dest_path)
+        src = src_path  # Using src_path as is
+        dest = dest_path  # Using dest_path as is
         disp_src = display_path(original_src)
         disp_dest = display_path(original_dest)
         backup_path = None
@@ -82,19 +84,16 @@ class MoveFileTool(ToolBase):
                 )
                 return tr("❌ Error removing destination before move: {error}", error=e)
         try:
-            shutil.move(src, dest)
-            self.report_success(
+            self.report_info(
                 tr(
-                    "✅ Moved from '{disp_src}' to '{disp_dest}'",
+                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
                     disp_src=disp_src,
                     disp_dest=disp_dest,
                 )
             )
-            msg = tr(
-                "✅ Successfully moved from '{disp_src}' to '{disp_dest}'.",
-                disp_src=disp_src,
-                disp_dest=disp_dest,
-            )
+            shutil.move(src, dest)
+            self.report_success(tr("✅ Move complete."))
+            msg = tr("✅ Move complete.")
             if backup_path:
                 msg += tr(
                     " (backup at {backup_disp})",

janito/agent/tools/remove_directory.py

@@ -1,6 +1,6 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.tools_utils import pluralize, display_path
+from janito.agent.tools_utils.utils import pluralize, display_path
 from janito.i18n import tr
 import shutil
 import os
@@ -24,7 +24,7 @@ class RemoveDirectoryTool(ToolBase):
     def run(self, file_path: str, recursive: bool = False) -> str:
         disp_path = display_path(file_path)
         self.report_info(
-            tr("🗃️  Removing directory: {disp_path} ...", disp_path=disp_path)
+            tr("🗃️ Removing directory '{disp_path}' ...", disp_path=disp_path)
         )
         backup_zip = None
         try:

janito/agent/tools/remove_file.py

@@ -1,7 +1,9 @@
 import os
 import shutil
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.utils import expand_path, display_path
+
+# from janito.agent.tools_utils.expand_path import expand_path
+from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
 from janito.i18n import tr
 
@@ -22,27 +24,23 @@ class RemoveFileTool(ToolBase):
 
     def run(self, file_path: str, backup: bool = False) -> str:
         original_path = file_path
-        path = expand_path(file_path)
+        path = file_path  # Using file_path as is
         disp_path = display_path(original_path)
         backup_path = None
+        # Report initial info about what is going to be removed
+        self.report_info(tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path))
         if not os.path.exists(path):
-            self.report_error(
-                tr("❌ File '{disp_path}' does not exist.", disp_path=disp_path)
-            )
-            return tr("❌ File '{disp_path}' does not exist.", disp_path=disp_path)
+            self.report_error(tr("❌ File does not exist."))
+            return tr("❌ File does not exist.")
         if not os.path.isfile(path):
-            self.report_error(
-                tr("❌ Path '{disp_path}' is not a file.", disp_path=disp_path)
-            )
-            return tr("❌ Path '{disp_path}' is not a file.", disp_path=disp_path)
+            self.report_error(tr("❌ Path is not a file."))
+            return tr("❌ Path is not a file.")
         try:
             if backup:
                 backup_path = path + ".bak"
                 shutil.copy2(path, backup_path)
             os.remove(path)
-            self.report_success(
-                tr("✅ File removed: '{disp_path}'", disp_path=disp_path)
-            )
+            self.report_success(tr("✅ File removed"))
             msg = tr(
                 "✅ Successfully removed the file at '{disp_path}'.",
                 disp_path=disp_path,

janito/agent/tools/replace_file.py

@@ -0,0 +1,62 @@
+import os
+import shutil
+from janito.agent.tool_registry import register_tool
+from janito.agent.tools_utils.utils import display_path
+from janito.agent.tool_base import ToolBase
+from janito.i18n import tr
+
+from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
+
+
+@register_tool(name="replace_file")
+class ReplaceFileTool(ToolBase):
+    """
+    Replace the entire content of an existing file. Fails if the file does not exist.
+    Args:
+        file_path (str): Path to the file to replace content.
+        content (str): The full new content to write to the file. You must provide the complete content as it will fully overwrite the existing file—do not use placeholders for original content.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "✅ Successfully replaced the file at ..."
+    """
+
+    def run(self, file_path: str, content: str) -> str:
+        from janito.agent.tool_use_tracker import ToolUseTracker
+
+        expanded_file_path = file_path  # Using file_path as is
+        disp_path = display_path(expanded_file_path)
+        file_path = expanded_file_path
+        if not os.path.exists(file_path):
+            return tr(
+                "❗ Cannot replace: file does not exist at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+        # Check previous operation
+        tracker = ToolUseTracker()
+        if not tracker.last_operation_is_full_read_or_replace(file_path):
+            self.report_warning(tr("ℹ️ Missing full view."))
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    current_content = f.read()
+            except Exception as e:
+                current_content = f"[Error reading file: {e}]"
+            return (
+                "⚠️ [missing full view] You must fully view or replace the file before updating.\n"
+                f"--- Current content of {disp_path} ---\n"
+                f"{current_content}"
+            )
+        self.report_info(tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path))
+        backup_path = file_path + ".bak"
+        shutil.copy2(file_path, backup_path)
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(tr("✅ {new_lines} lines", new_lines=new_lines))
+        msg = tr(
+            "✅ Replaced file ({new_lines} lines, backup at {backup_path}).",
+            new_lines=new_lines,
+            backup_path=backup_path,
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(file_path)
+        return msg + f"\n{validation_result}"

janito/agent/tools/replace_text_in_file.py

@@ -29,7 +29,7 @@ class ReplaceTextInFileTool(ToolBase):
         replace_all: bool = False,
         backup: bool = False,
     ) -> str:
-        from janito.agent.tools.tools_utils import display_path
+        from janito.agent.tools_utils.utils import display_path
 
         disp_path = display_path(file_path)
         action = "(all)" if replace_all else "(unique)"
@@ -95,7 +95,7 @@ class ReplaceTextInFileTool(ToolBase):
             else:
                 occurrences = content.count(search_text)
                 if occurrences > 1:
-                    self.report_warning(tr("⚠️ Search text is not unique."))
+                    self.report_warning(tr(" ℹ️ No changes made. [not unique]"))
                     warning_detail = tr(
                         "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
                     )
@@ -120,7 +120,7 @@ class ReplaceTextInFileTool(ToolBase):
             if replaced_count == 0:
                 warning = tr(" [Warning: Search text not found in file]")
             if not file_changed:
-                self.report_warning(tr(" ℹ️ No changes made."))
+                self.report_warning(tr(" ℹ️ No changes made. [not found]"))
                 concise_warning = tr(
                     "The search text was not found. Expand your search context with surrounding lines if needed."
                 )

janito/agent/tools/run_bash_command.py

@@ -29,15 +29,11 @@ class RunBashCommandTool(ToolBase):
         interactive: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning(
-                tr("⚠️ Warning: Empty command provided. Operation skipped.")
-            )
+            self.report_warning(tr("ℹ️ Empty command provided."))
             return tr("Warning: Empty command provided. Operation skipped.")
-        self.report_info(
-            tr("🖥️  Running bash command: {command} ...\n", command=command)
-        )
+        self.report_info(tr("🖥️ Running bash command: {command} ...\n", command=command))
         if interactive:
-            self.report_info(
+            self.report_warning(
                 tr(
                     "⚠️  Warning: This command might be interactive, require user input, and might hang."
                 )

janito/agent/tools/run_powershell_command.py

@@ -3,6 +3,7 @@ from janito.agent.tool_registry import register_tool
 from janito.i18n import tr
 import subprocess
 import tempfile
+import threading
 
 
 @register_tool(name="run_powershell_command")
@@ -30,17 +31,15 @@ class RunPowerShellCommandTool(ToolBase):
         interactive: bool = False,
     ) -> str:
         if not command.strip():
-            self.report_warning(
-                tr("⚠️ Warning: Empty command provided. Operation skipped.")
-            )
+            self.report_warning(tr("ℹ️ Empty command provided."))
             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_info(
-            tr("🖥️  Running PowerShell command: {command} ...\n", command=command)
+            tr("🖥️ Running PowerShell command: {command} ...\n", command=command)
         )
         if interactive:
-            self.report_info(
+            self.report_warning(
                 tr(
                     "⚠️  Warning: This command might be interactive, require user input, and might hang."
                 )
@@ -53,7 +52,7 @@ class RunPowerShellCommandTool(ToolBase):
                 )
             )
             if not confirmed:
-                self.report_warning(tr("Execution cancelled by user."))
+                self.report_warning(tr("⚠️ Execution cancelled by user."))
                 return tr("❌ Command execution cancelled by user.")
         from janito.agent.platform_discovery import is_windows
 
@@ -82,10 +81,38 @@ class RunPowerShellCommandTool(ToolBase):
                         "-Command",
                         command_with_encoding,
                     ],
-                    stdout=stdout_file,
-                    stderr=stderr_file,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
                     text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
                 )
+
+                stdout_lines = 0
+                stderr_lines = 0
+
+                def stream_output(stream, file_obj, report_func, count_func):
+                    nonlocal stdout_lines, stderr_lines
+                    for line in stream:
+                        file_obj.write(line)
+                        file_obj.flush()
+                        report_func(line)
+                        if count_func == "stdout":
+                            stdout_lines += 1
+                        else:
+                            stderr_lines += 1
+
+                stdout_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                )
+                stderr_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
                 except subprocess.TimeoutExpired:
@@ -96,28 +123,11 @@ class RunPowerShellCommandTool(ToolBase):
                     return tr(
                         "Command timed out after {timeout} seconds.", timeout=timeout
                     )
+                stdout_thread.join()
+                stderr_thread.join()
                 stdout_file.flush()
                 stderr_file.flush()
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        self.report_stdout(line)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        self.report_stderr(line)
-                with open(
-                    stdout_file.name, "r", encoding="utf-8", errors="replace"
-                ) as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(
-                    stderr_file.name, "r", encoding="utf-8", errors="replace"
-                ) as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
+
                 self.report_success(
                     tr(" ✅ return code {return_code}", return_code=return_code)
                 )
@@ -126,6 +136,7 @@ class RunPowerShellCommandTool(ToolBase):
                     warning_msg = tr(
                         "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
                     )
+                # Read back the content for summary if not too large
                 with open(
                     stdout_file.name, "r", encoding="utf-8", errors="replace"
                 ) as out_f:

janito/agent/tools/run_python_command.py

@@ -28,13 +28,11 @@ class RunPythonCommandTool(ToolBase):
         interactive: bool = False,
     ) -> str:
         if not code.strip():
-            self.report_warning(
-                tr("⚠️ Warning: Empty code provided. Operation skipped.")
-            )
+            self.report_warning(tr("ℹ️ Empty code provided."))
             return tr("Warning: Empty code provided. Operation skipped.")
         self.report_info(tr("🐍 Running Python code: ...\n{code}\n", code=code))
         if interactive:
-            self.report_info(
+            self.report_warning(
                 tr(
                     "⚠️  Warning: This code might be interactive, require user input, and might hang."
                 )
@@ -45,7 +43,7 @@ class RunPythonCommandTool(ToolBase):
                 tr("Do you want to execute this Python code?")
             )
             if not confirmed:
-                self.report_warning(tr("Execution cancelled by user."))
+                self.report_warning(tr("⚠️ Execution cancelled by user."))
                 return tr("Execution cancelled by user.")
         try:
             with (

janito/agent/tools/search_text.py

@@ -1,10 +1,10 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.tools_utils import pluralize
+from janito.agent.tools_utils.utils import pluralize
 from janito.i18n import tr
 import os
 import re
-from janito.agent.tools.gitignore_utils import filter_ignored
+from janito.agent.tools_utils.gitignore_utils import filter_ignored
 
 
 def is_binary_file(path, blocksize=1024):
@@ -31,7 +31,8 @@ class SearchTextTool(ToolBase):
 
     Args:
         paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
-        pattern (str): Regex pattern or plain text substring to search for in files. Tries regex first, falls back to substring if regex is invalid.
+        pattern (str): Regex pattern or plain text substring to search for in files. Must not be empty. Tries regex first, falls back to substring if regex is invalid.
+            Note: When using regex mode, special characters (such as [, ], ., *, etc.) must be escaped if you want to match them literally (e.g., use '\\[DEBUG\\]' to match the literal string '[DEBUG]').
         is_regex (bool): If True, treat pattern as regex. If False, treat as plain text. Defaults to False.
         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): Maximum number of results to return. 0 means no limit (default).
@@ -51,10 +52,10 @@ class SearchTextTool(ToolBase):
         ignore_utf8_errors: bool = True,
     ) -> str:
         if not pattern:
-            self.report_warning(
-                tr("⚠️ Warning: Empty search pattern provided. Operation skipped.")
+            self.report_error(
+                tr("Error: Empty search pattern provided. Operation aborted.")
             )
-            return tr("Warning: Empty search pattern provided. Operation skipped.")
+            return tr("Error: Empty search pattern provided. Operation aborted.")
         regex = None
         use_regex = False
         if is_regex:
@@ -62,12 +63,7 @@ class SearchTextTool(ToolBase):
                 regex = re.compile(pattern)
                 use_regex = True
             except re.error as e:
-                self.report_warning(
-                    tr(
-                        "Invalid regex pattern: {error}. Falling back to no results.",
-                        error=e,
-                    )
-                )
+                self.report_warning(tr("⚠️ Invalid regex pattern."))
                 return tr(
                     "Warning: Invalid regex pattern: {error}. No results.", error=e
                 )
@@ -83,7 +79,7 @@ class SearchTextTool(ToolBase):
         total_results = 0
         paths_list = paths.split()
         for search_path in paths_list:
-            from janito.agent.tools.tools_utils import display_path
+            from janito.agent.tools_utils.utils import display_path
 
             info_str = tr(
                 "🔍 Searching for {search_type} '{pattern}' in '{disp_path}'",
@@ -199,7 +195,7 @@ class SearchTextTool(ToolBase):
             result += tr("\n[Note: max_results limit reached, output truncated.]")
         self.report_success(
             tr(
-                " ✅ {count} {line_word} found{limit}",
+                " ✅ {count} {line_word}{limit}",
                 count=len(output),
                 line_word=pluralize("line", len(output)),
                 limit=(" (limit reached)" if limit_reached else ""),

janito/agent/tools/validate_file_syntax/__init__.py

@@ -0,0 +1 @@
+# Validation syntax package

janito/agent/tools/validate_file_syntax/core.py

@@ -0,0 +1,92 @@
+import os
+from janito.i18n import tr
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.agent.tools_utils.utils import display_path
+
+from .python_validator import validate_python
+from .json_validator import validate_json
+from .yaml_validator import validate_yaml
+from .ps1_validator import validate_ps1
+from .xml_validator import validate_xml
+from .html_validator import validate_html
+from .markdown_validator import validate_markdown
+from .js_validator import validate_js
+from .css_validator import validate_css
+
+
+def validate_file_syntax(
+    file_path: str, report_info=None, report_warning=None, report_success=None
+) -> str:
+    ext = os.path.splitext(file_path)[1].lower()
+    try:
+        if ext in [".py", ".pyw"]:
+            return validate_python(file_path)
+        elif ext == ".json":
+            return validate_json(file_path)
+        elif ext in [".yml", ".yaml"]:
+            return validate_yaml(file_path)
+        elif ext == ".ps1":
+            return validate_ps1(file_path)
+        elif ext == ".xml":
+            return validate_xml(file_path)
+        elif ext in (".html", ".htm"):
+            return validate_html(file_path)
+        elif ext == ".md":
+            return validate_markdown(file_path)
+        elif ext == ".js":
+            return validate_js(file_path)
+        elif ext == ".css":
+            return validate_css(file_path)
+        else:
+            msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
+            if report_warning:
+                report_warning(msg)
+            return msg
+    except Exception as e:
+        msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
+        if report_warning:
+            report_warning(msg)
+        return msg
+
+
+@register_tool(name="validate_file_syntax")
+class ValidateFileSyntaxTool(ToolBase):
+    """
+    Validate a file for syntax issues.
+
+    Supported types:
+      - Python (.py, .pyw)
+      - JSON (.json)
+      - YAML (.yml, .yaml)
+      - PowerShell (.ps1)
+      - XML (.xml)
+      - HTML (.html, .htm) [lxml]
+      - Markdown (.md)
+      - JavaScript (.js)
+
+    Args:
+        file_path (str): Path to the file to validate.
+    Returns:
+        str: Validation status message. Example:
+            - "✅ Syntax OK"
+            - "⚠️ Warning: Syntax error: <error message>"
+            - "⚠️ Warning: Unsupported file extension: <ext>"
+    """
+
+    def run(self, file_path: str) -> str:
+        disp_path = display_path(file_path)
+        self.report_info(
+            tr("🔎 Validating syntax for file '{disp_path}' ...", disp_path=disp_path)
+        )
+        result = validate_file_syntax(
+            file_path,
+            report_info=self.report_info,
+            report_warning=self.report_warning,
+            report_success=self.report_success,
+        )
+        if result.startswith("✅"):
+            self.report_success(result)
+        elif result.startswith("⚠️"):
+            self.report_warning(tr("⚠️ ") + result.lstrip("⚠️ "))
+        return result

janito/agent/tools/validate_file_syntax/css_validator.py

@@ -0,0 +1,35 @@
+from janito.i18n import tr
+import re
+
+
+def validate_css(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    # Check for unmatched curly braces
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    # Check for unclosed comments
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed comment (/* ... */)")
+    # Check for invalid property declarations (very basic)
+    for i, line in enumerate(content.splitlines(), 1):
+        # Ignore empty lines and comments
+        if not line.strip() or line.strip().startswith("/*"):
+            continue
+        # Match property: value; (allow whitespace)
+        if ":" in line and not re.search(r":.*;", line):
+            errors.append(
+                f"Line {i}: Missing semicolon after property value | {line.strip()}"
+            )
+        # Match lines with property but missing colon
+        if ";" in line and ":" not in line:
+            errors.append(
+                f"Line {i}: Missing colon in property declaration | {line.strip()}"
+            )
+    if errors:
+        msg = tr(
+            "⚠️ Warning: CSS syntax issues found:\n{errors}", errors="\n".join(errors)
+        )
+        return msg
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/html_validator.py

@@ -0,0 +1,77 @@
+from janito.i18n import tr
+import re
+from lxml import etree
+
+
+def validate_html(file_path: str) -> str:
+    warnings = []
+    with open(file_path, "r", encoding="utf-8") as f:
+        html_content = f.read()
+    script_blocks = [
+        m.span()
+        for m in re.finditer(
+            r"<script[\s\S]*?>[\s\S]*?<\/script>", html_content, re.IGNORECASE
+        )
+    ]
+    js_patterns = [
+        r"document\.addEventListener",
+        r"^\s*(var|let|const)\s+\w+\s*[=;]",
+        r"^\s*function\s+\w+\s*\(",
+        r"^\s*(const|let|var)\s+\w+\s*=\s*\(.*\)\s*=>",
+        r"^\s*window\.\w+\s*=",
+        r"^\s*\$\s*\(",
+    ]
+    for pat in js_patterns:
+        for m in re.finditer(pat, html_content):
+            in_script = False
+            for s_start, s_end in script_blocks:
+                if s_start <= m.start() < s_end:
+                    in_script = True
+                    break
+            if not in_script:
+                warnings.append(
+                    f"Line {html_content.count(chr(10), 0, m.start())+1}: JavaScript code ('{pat}') found outside <script> tag."
+                )
+    lxml_error = None
+    try:
+        # Parse HTML and collect error log
+        parser = etree.HTMLParser(recover=False)
+        with open(file_path, "rb") as f:
+            etree.parse(f, parser=parser)
+        error_log = parser.error_log
+        # Look for tag mismatch or unclosed tag errors
+        syntax_errors = []
+        for e in error_log:
+            if (
+                "mismatch" in e.message.lower()
+                or "tag not closed" in e.message.lower()
+                or "unexpected end tag" in e.message.lower()
+                or "expected" in e.message.lower()
+            ):
+                syntax_errors.append(str(e))
+        if syntax_errors:
+            lxml_error = tr("Syntax error: {error}", error="; ".join(syntax_errors))
+        elif error_log:
+            # Other warnings
+            lxml_error = tr(
+                "HTML syntax errors found:\n{errors}",
+                errors="\n".join(str(e) for e in error_log),
+            )
+    except ImportError:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+    except Exception as e:
+        lxml_error = tr("Syntax error: {error}", error=str(e))
+    msg = ""
+    if warnings:
+        msg += (
+            tr(
+                "⚠️ Warning: JavaScript code found outside <script> tags. This is invalid HTML and will not execute in browsers.\n"
+                + "\n".join(warnings)
+            )
+            + "\n"
+        )
+    if lxml_error:
+        msg += lxml_error
+    if msg:
+        return msg.strip()
+    return "✅ Syntax valid"

janito/agent/tools/validate_file_syntax/js_validator.py

@@ -0,0 +1,27 @@
+from janito.i18n import tr
+import re
+
+
+def validate_js(file_path: str) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    errors = []
+    if content.count("{") != content.count("}"):
+        errors.append("Unmatched curly braces { }")
+    if content.count("(") != content.count(")"):
+        errors.append("Unmatched parentheses ( )")
+    if content.count("[") != content.count("]"):
+        errors.append("Unmatched brackets [ ]")
+    for quote in ["'", '"', "`"]:
+        unescaped = re.findall(rf"(?<!\\){quote}", content)
+        if len(unescaped) % 2 != 0:
+            errors.append(f"Unclosed string literal ({quote}) detected")
+    if content.count("/*") != content.count("*/"):
+        errors.append("Unclosed block comment (/* ... */)")
+    if errors:
+        msg = tr(
+            "⚠️ Warning: JavaScript syntax issues found:\n{errors}",
+            errors="\n".join(errors),
+        )
+        return msg
+    return "✅ Syntax valid"