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

janito/agent/tools/run_python_command.py

@@ -1,15 +1,16 @@
 import subprocess
 import tempfile
 import sys
+import os
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
 
 
 @register_tool(name="run_python_command")
 class RunPythonCommandTool(ToolBase):
     """
     Tool to execute Python code in a subprocess and capture output.
-
     Args:
         code (str): The Python code to execute.
         timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
@@ -19,7 +20,7 @@ class RunPythonCommandTool(ToolBase):
         str: File paths and line counts for stdout and stderr, or direct output if small enough.
     """
 
-    def call(
+    def run(
         self,
         code: str,
         timeout: int = 60,
@@ -27,19 +28,25 @@ class RunPythonCommandTool(ToolBase):
         interactive: bool = False,
     ) -> str:
         if not code.strip():
-            self.report_warning("⚠️ Warning: Empty code provided. Operation skipped.")
-            return "Warning: Empty code provided. Operation skipped."
-        self.report_info(f"🐍 Running Python code:\n{code}\n")
+            self.report_warning(
+                tr("⚠️ Warning: Empty code provided. Operation skipped.")
+            )
+            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(
-                "⚠️  Warning: This code might be interactive, require user input, and might hang."
+                tr(
+                    "⚠️  Warning: This code might be interactive, require user input, and might hang."
+                )
             )
         sys.stdout.flush()
         if require_confirmation:
-            confirmed = self.confirm_action("Do you want to execute this Python code?")
+            confirmed = self.confirm_action(
+                tr("Do you want to execute this Python code?")
+            )
             if not confirmed:
-                self.report_warning("Execution cancelled by user.")
-                return "Execution cancelled by user."
+                self.report_warning(tr("Execution cancelled by user."))
+                return tr("Execution cancelled by user.")
         try:
             with (
                 tempfile.NamedTemporaryFile(
@@ -64,19 +71,25 @@ class RunPythonCommandTool(ToolBase):
             ):
                 code_file.write(code)
                 code_file.flush()
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
                 process = subprocess.Popen(
                     [sys.executable, code_file.name],
                     stdout=stdout_file,
                     stderr=stderr_file,
                     text=True,
+                    env=env,
                 )
                 try:
                     return_code = process.wait(timeout=timeout)
                 except subprocess.TimeoutExpired:
                     process.kill()
-                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
-                    return f"Code timed out after {timeout} seconds."
-                # Print live output to user
+                    self.report_error(
+                        tr(" ❌ Timed out after {timeout} seconds.", timeout=timeout)
+                    )
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
                 stdout_file.flush()
                 stderr_file.flush()
                 with open(
@@ -91,7 +104,6 @@ class RunPythonCommandTool(ToolBase):
                     err_f.seek(0)
                     for line in err_f:
                         self.report_stderr(line)
-                # Count lines
                 with open(
                     stdout_file.name, "r", encoding="utf-8", errors="replace"
                 ) as out_f:
@@ -100,11 +112,14 @@ class RunPythonCommandTool(ToolBase):
                     stderr_file.name, "r", encoding="utf-8", errors="replace"
                 ) as err_f:
                     stderr_lines = sum(1 for _ in err_f)
-                self.report_success(f" ✅ return code {return_code}")
+                self.report_success(
+                    tr(" ✅ return code {return_code}", return_code=return_code)
+                )
                 warning_msg = ""
                 if interactive:
-                    warning_msg = "⚠️  Warning: This code might be interactive, require user input, and might hang.\n"
-                # Read output contents
+                    warning_msg = tr(
+                        "⚠️  Warning: This code might be interactive, require user input, and might hang.\n"
+                    )
                 with open(
                     stdout_file.name, "r", encoding="utf-8", errors="replace"
                 ) as out_f:
@@ -113,27 +128,36 @@ class RunPythonCommandTool(ToolBase):
                     stderr_file.name, "r", encoding="utf-8", errors="replace"
                 ) as err_f:
                     stderr_content = err_f.read()
-                # Thresholds
                 max_lines = 100
                 if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = (
-                        warning_msg
-                        + f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    result = warning_msg + tr(
+                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                        return_code=return_code,
+                        stdout_content=stdout_content,
                     )
                     if stderr_content.strip():
-                        result += f"\n--- STDERR ---\n{stderr_content}"
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content,
+                        )
                     return result
                 else:
-                    result = (
-                        warning_msg
-                        + f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    result = warning_msg + tr(
+                        "stdout_file: {stdout_file} (lines: {stdout_lines})\n",
+                        stdout_file=stdout_file.name,
+                        stdout_lines=stdout_lines,
                     )
                     if stderr_lines > 0 and stderr_content.strip():
-                        result += (
-                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        result += tr(
+                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                            stderr_file=stderr_file.name,
+                            stderr_lines=stderr_lines,
                         )
-                    result += f"returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed."
+                    result += tr(
+                        "returncode: {return_code}\nUse the get_lines tool to inspect the contents of these files when needed.",
+                        return_code=return_code,
+                    )
                     return result
         except Exception as e:
-            self.report_error(f" ❌ Error: {e}")
-            return f"Error running code: {e}"
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error running code: {error}", error=e)

janito/agent/tools/search_outline.py

@@ -0,0 +1,17 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+
+@register_tool(name="search_outline")
+class SearchOutlineTool(ToolBase):
+    """
+    Tool for searching outlines in files.
+    """
+
+    def run(self, file_path: str) -> str:
+        # ... 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_success(tr("✅ {count} {match_word} found", count=len(output), match_word=pluralize('match', len(output))))
+        pass

janito/agent/tools/search_text.py

@@ -0,0 +1,208 @@
+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.i18n import tr
+import os
+import re
+from janito.agent.tools.gitignore_utils import filter_ignored
+
+
+def is_binary_file(path, blocksize=1024):
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(blocksize)
+            if b"\0" in chunk:
+                return True
+            text_characters = bytearray(
+                {7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100))
+            )
+            nontext = chunk.translate(None, text_characters)
+            if len(nontext) / max(1, len(chunk)) > 0.3:
+                return True
+    except Exception:
+        return True
+    return False
+
+
+@register_tool(name="search_text")
+class SearchTextTool(ToolBase):
+    """
+    Search for a text pattern (regex or plain string) in all files within one or more directories or file paths and return matching lines. Respects .gitignore.
+
+    Args:
+        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
+        pattern (str): Regex pattern or plain text substring to search for in files. Tries regex first, falls back to substring if regex is invalid.
+        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).
+        ignore_utf8_errors (bool): If True, ignore utf-8 decode errors. Defaults to True.
+    Returns:
+        str: Matching lines from files as a newline-separated string, each formatted as 'filepath:lineno: line'.
+        If max_results is reached, appends a note to the output.
+    """
+
+    def run(
+        self,
+        paths: str,
+        pattern: str,
+        is_regex: bool = False,
+        max_depth: int = 0,
+        max_results: int = 0,
+        ignore_utf8_errors: bool = True,
+    ) -> str:
+        if not pattern:
+            self.report_warning(
+                tr("⚠️ Warning: Empty search pattern provided. Operation skipped.")
+            )
+            return tr("Warning: Empty search pattern provided. Operation skipped.")
+        regex = None
+        use_regex = False
+        if is_regex:
+            try:
+                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,
+                    )
+                )
+                return tr(
+                    "Warning: Invalid regex pattern: {error}. No results.", error=e
+                )
+        else:
+            try:
+                regex = re.compile(pattern)
+                use_regex = True
+            except re.error:
+                regex = None
+                use_regex = False
+        output = []
+        limit_reached = False
+        total_results = 0
+        paths_list = paths.split()
+        for search_path in paths_list:
+            from janito.agent.tools.tools_utils import display_path
+
+            info_str = tr(
+                "🔍 Searching for {search_type} '{pattern}' in '{disp_path}'",
+                search_type=("text-regex" if use_regex else "text"),
+                pattern=pattern,
+                disp_path=display_path(search_path),
+            )
+            if max_depth > 0:
+                info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
+            self.report_info(info_str)
+            dir_output = []
+            dir_limit_reached = False
+            if os.path.isfile(search_path):
+                # Handle single file
+                path = search_path
+                if not is_binary_file(path):
+                    try:
+                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
+                        if ignore_utf8_errors:
+                            open_kwargs["errors"] = "ignore"
+                        with open(path, **open_kwargs) as f:
+                            for lineno, line in enumerate(f, 1):
+                                if use_regex:
+                                    if regex.search(line):
+                                        dir_output.append(
+                                            f"{path}:{lineno}: {line.strip()}"
+                                        )
+                                else:
+                                    if pattern in line:
+                                        dir_output.append(
+                                            f"{path}:{lineno}: {line.strip()}"
+                                        )
+                                if (
+                                    max_results > 0
+                                    and (total_results + len(dir_output)) >= max_results
+                                ):
+                                    dir_limit_reached = True
+                                    break
+                    except Exception:
+                        pass
+                output.extend(dir_output)
+                total_results += len(dir_output)
+                if dir_limit_reached:
+                    limit_reached = True
+                    break
+                continue
+            # Directory logic as before
+            if max_depth == 1:
+                walk_result = next(os.walk(search_path), None)
+                if walk_result is None:
+                    walker = [(search_path, [], [])]
+                else:
+                    _, dirs, files = walk_result
+                    dirs, files = filter_ignored(search_path, dirs, files)
+                    walker = [(search_path, dirs, files)]
+            else:
+                walker = os.walk(search_path)
+            stop_search = False
+            for root, dirs, files in walker:
+                if stop_search:
+                    break
+                rel_path = os.path.relpath(root, search_path)
+                depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+                if max_depth == 1 and depth > 0:
+                    break
+                if max_depth > 0 and depth > max_depth:
+                    continue
+                dirs, files = filter_ignored(root, dirs, files)
+                for filename in files:
+                    if stop_search:
+                        break
+                    path = os.path.join(root, filename)
+                    if is_binary_file(path):
+                        continue
+                    try:
+                        open_kwargs = {"mode": "r", "encoding": "utf-8"}
+                        if ignore_utf8_errors:
+                            open_kwargs["errors"] = "ignore"
+                        with open(path, **open_kwargs) as f:
+                            for lineno, line in enumerate(f, 1):
+                                if use_regex:
+                                    if regex.search(line):
+                                        dir_output.append(
+                                            f"{path}:{lineno}: {line.strip()}"
+                                        )
+                                else:
+                                    if pattern in line:
+                                        dir_output.append(
+                                            f"{path}:{lineno}: {line.strip()}"
+                                        )
+                                if (
+                                    max_results > 0
+                                    and (total_results + len(dir_output)) >= max_results
+                                ):
+                                    dir_limit_reached = True
+                                    stop_search = True
+                                    break
+                    except Exception:
+                        continue
+            output.extend(dir_output)
+            total_results += len(dir_output)
+            if dir_limit_reached:
+                limit_reached = True
+                break
+        header = tr(
+            "[search_text] Pattern: '{pattern}' | Regex: {use_regex} | Results: {count}",
+            pattern=pattern,
+            use_regex=use_regex,
+            count=len(output),
+        )
+        result = header + "\n" + "\n".join(output)
+        if limit_reached:
+            result += tr("\n[Note: max_results limit reached, output truncated.]")
+        self.report_success(
+            tr(
+                " ✅ {count} {line_word} found{limit}",
+                count=len(output),
+                line_word=pluralize("line", len(output)),
+                limit=(" (limit reached)" if limit_reached else ""),
+            )
+        )
+        return result

janito/agent/tools/tools_utils.py

@@ -1,9 +1,27 @@
-def display_path(path):
-    import os
+import os
+import urllib.parse
+from janito.agent.tools.gitignore_utils import filter_ignored
+from janito.agent.runtime_config import runtime_config
+
 
+def display_path(path):
+    """
+    Returns a display-friendly path. If runtime_config['termweb_port'] is set, injects an ANSI hyperlink to the local web file viewer.
+    Args:
+        path (str): Path to display.
+    Returns:
+        str: Display path, optionally as an ANSI hyperlink.
+    """
     if os.path.isabs(path):
-        return path
-    return os.path.relpath(path)
+        disp = path
+    else:
+        disp = os.path.relpath(path)
+    port = runtime_config.get("termweb_port")
+    if port:
+        url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
+        # Use Rich markup for hyperlinks
+        return f"[link={url}]{disp}[/link]"
+    return disp
 
 
 def pluralize(word: str, count: int) -> str:
@@ -11,3 +29,28 @@ def pluralize(word: str, count: int) -> str:
     if count == 1 or word.endswith("s"):
         return word
     return word + "s"
+
+
+def find_files_with_extensions(directories, extensions, max_depth=0):
+    """
+    Find files in given directories with specified extensions, respecting .gitignore.
+
+    Args:
+        directories (list[str]): Directories to search.
+        extensions (list[str]): File extensions to include (e.g., ['.py', '.md']).
+        max_depth (int, optional): Maximum directory depth to search. If 0, unlimited.
+    Returns:
+        list[str]: List of matching file paths.
+    """
+    output = []
+    for directory in directories:
+        for root, dirs, files in os.walk(directory):
+            rel_path = os.path.relpath(root, directory)
+            depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+            if max_depth > 0 and depth > max_depth:
+                continue
+            dirs, files = filter_ignored(root, dirs, files)
+            for filename in files:
+                if any(filename.lower().endswith(ext) for ext in extensions):
+                    output.append(os.path.join(root, filename))
+    return output

janito/agent/tools/utils.py

@@ -11,24 +11,23 @@ def expand_path(path: str) -> str:
     return path
 
 
-def display_path(original_path: str, expanded_path: str) -> str:
+def display_path(path: str) -> str:
     """
     Returns a user-friendly path for display:
-    - If the original path is relative, return it as-is.
-    - If the original path starts with ~, keep it as ~.
-    - Otherwise, if the expanded path is under the home directory, replace the home dir with ~.
-    - Else, show the expanded path.
+    - If the path is relative, return it as-is.
+    - If the path starts with ~, keep it as ~.
+    - If the path is under the home directory, replace the home dir with ~.
+    - Else, show the absolute path.
     """
-    # Detect relative path (POSIX or Windows)
     if not (
-        original_path.startswith("/")
-        or original_path.startswith("~")
-        or (os.name == "nt" and len(original_path) > 1 and original_path[1] == ":")
+        path.startswith("/")
+        or path.startswith("~")
+        or (os.name == "nt" and len(path) > 1 and path[1] == ":")
     ):
-        return original_path
+        return path
     home = os.path.expanduser("~")
-    if original_path.startswith("~"):
-        return original_path
-    if expanded_path.startswith(home):
-        return "~" + expanded_path[len(home) :]
-    return expanded_path
+    if path.startswith("~"):
+        return path
+    if path.startswith(home):
+        return "~" + path[len(home) :]
+    return path

janito/agent/tools/validate_file_syntax.py

@@ -0,0 +1,163 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+import os
+import json
+import yaml
+from janito.agent.tools.utils import display_path
+
+
+@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]
+
+    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: {disp_path} ...", disp_path=disp_path)
+        )
+        ext = os.path.splitext(file_path)[1].lower()
+        try:
+            if ext in [".py", ".pyw"]:
+                import py_compile
+
+                py_compile.compile(file_path, doraise=True)
+            elif ext == ".json":
+                with open(file_path, "r", encoding="utf-8") as f:
+                    json.load(f)
+            elif ext in [".yml", ".yaml"]:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    yaml.safe_load(f)
+            elif ext == ".ps1":
+                from janito.agent.tools.run_powershell_command import (
+                    RunPowerShellCommandTool,
+                )
+
+                ps_tool = RunPowerShellCommandTool()
+                check_cmd = "if (Get-Command Invoke-ScriptAnalyzer -ErrorAction SilentlyContinue) { Write-Output 'PSScriptAnalyzerAvailable' } else { Write-Output 'PSScriptAnalyzerMissing' }"
+                check_result = ps_tool.run(command=check_cmd, timeout=15)
+                if "PSScriptAnalyzerMissing" in check_result:
+                    msg = tr(
+                        "⚠️ Warning: PSScriptAnalyzer is not installed. For best PowerShell syntax validation, install it with:\n    Install-Module -Name PSScriptAnalyzer -Scope CurrentUser\n"
+                    )
+                    self.report_warning(msg)
+                    return msg
+                analyze_cmd = f"Invoke-ScriptAnalyzer -Path '{file_path}' -Severity Error | ConvertTo-Json"
+                analyze_result = ps_tool.run(command=analyze_cmd, timeout=30)
+                if "[]" in analyze_result or analyze_result.strip() == "":
+                    self.report_success(tr("✅ Syntax OK"))
+                    return tr("✅ Syntax valid")
+                else:
+                    msg = tr(
+                        "⚠️ Warning: PowerShell syntax issues found:\n{analyze_result}",
+                        analyze_result=analyze_result,
+                    )
+                    self.report_warning(msg)
+                    return msg
+            elif ext == ".xml":
+                try:
+                    from lxml import etree
+                except ImportError:
+                    msg = tr("⚠️ lxml not installed. Cannot validate XML.")
+                    self.report_warning(msg)
+                    return msg
+                with open(file_path, "rb") as f:
+                    etree.parse(f)
+            elif ext in (".html", ".htm"):
+                try:
+                    from lxml import html
+                except ImportError:
+                    msg = tr("⚠️ lxml not installed. Cannot validate HTML.")
+                    self.report_warning(msg)
+                    return msg
+                with open(file_path, "rb") as f:
+                    html.parse(f)
+                from lxml import etree
+
+                parser = etree.HTMLParser(recover=False)
+                with open(file_path, "rb") as f:
+                    etree.parse(f, parser=parser)
+                if parser.error_log:
+                    errors = "\n".join(str(e) for e in parser.error_log)
+                    raise ValueError(
+                        tr("HTML syntax errors found:\n{errors}", errors=errors)
+                    )
+            elif ext == ".md":
+                import re
+
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                errors = []
+                # Rule: Headers must start with # followed by a space
+                for i, line in enumerate(content.splitlines(), 1):
+                    if re.match(r"^#+[^ #]", line):
+                        errors.append(
+                            f"Line {i}: Header missing space after # | {line.strip()}"
+                        )
+                # Rule: Unclosed code blocks
+                if content.count("```") % 2 != 0:
+                    errors.append("Unclosed code block (```) detected")
+                # Rule: Unclosed links/images (flag only if line contains [text]( but not ))
+                for i, line in enumerate(content.splitlines(), 1):
+                    if re.search(r"\[[^\]]*\]\([^)]+$", line):
+                        errors.append(
+                            f"Line {i}: Unclosed link or image (missing closing parenthesis) | {line.strip()}"
+                        )
+                # Rule: List items must start with -, *, or + followed by space
+                for i, line in enumerate(content.splitlines(), 1):
+                    # Skip horizontal rules like --- or ***
+                    if re.match(r"^([-*+])\1{1,}", line):
+                        continue
+                    # Skip table rows (lines starting with |)
+                    if line.lstrip().startswith("|"):
+                        continue
+                    # Only flag as list item if there is text after the bullet (not just emphasis)
+                    if re.match(r"^[-*+][^ \n]", line):
+                        stripped = line.strip()
+                        # If the line is surrounded by * and ends with *, it's likely emphasis, not a list
+                        if not (
+                            stripped.startswith("*")
+                            and stripped.endswith("*")
+                            and len(stripped) > 2
+                        ):
+                            errors.append(
+                                f"Line {i}: List item missing space after bullet | {line.strip()}"
+                            )
+                # Rule: Inline code must have even number of backticks
+                if content.count("`") % 2 != 0:
+                    errors.append("Unclosed inline code (`) detected")
+                if errors:
+                    msg = tr(
+                        "⚠️ Warning: Markdown syntax issues found:\n{errors}",
+                        errors="\n".join(errors),
+                    )
+                    self.report_warning(msg)
+                    return msg
+            else:
+                msg = tr("⚠️ Warning: Unsupported file extension: {ext}", ext=ext)
+                self.report_warning(msg)
+                return msg
+            self.report_success(tr("✅ Syntax OK"))
+            return tr("✅ Syntax valid")
+        except Exception as e:
+            msg = tr("⚠️ Warning: Syntax error: {error}", error=e)
+            self.report_warning(msg)
+            return msg

janito/cli/_print_config.py

@@ -82,7 +82,7 @@ def print_full_config(
                 Path(__file__).parent
                 / "agent"
                 / "templates"
-                / "system_prompt_template.j2"
+                / "system_prompt_template_default.j2"
             )
             for key, value in default_items.items():
                 if key == "system_prompt_template" and value is None: