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

janito/agent/tools/ask_user.py

@@ -1,6 +1,15 @@
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
 
+from rich import print as rich_print
+from janito.i18n import tr
+from rich.panel import Panel
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.styles import Style
+
 
 @register_tool(name="ask_user")
 class AskUserTool(ToolBase):
@@ -16,16 +25,9 @@ class AskUserTool(ToolBase):
             - "Some detailed answer..."
     """
 
-    def call(self, question: str) -> str:
-        from rich import print as rich_print
-        from rich.panel import Panel
-        from prompt_toolkit import PromptSession
-        from prompt_toolkit.key_binding import KeyBindings
-        from prompt_toolkit.enums import EditingMode
-        from prompt_toolkit.formatted_text import HTML
-        from prompt_toolkit.styles import Style
+    def run(self, question: str) -> str:
 
-        rich_print(Panel.fit(question, title="Question", style="cyan"))
+        rich_print(Panel.fit(question, title=tr("Question"), style="cyan"))
 
         bindings = KeyBindings()
         mode = {"multiline": False}
@@ -34,12 +36,24 @@ class AskUserTool(ToolBase):
         def _(event):
             pass
 
+        # F12 instruction rotation
+        _f12_instructions = [
+            tr("proceed"),
+            tr("go ahead"),
+            tr("continue"),
+            tr("next"),
+            tr("okay"),
+        ]
+        _f12_index = {"value": 0}
+
         @bindings.add("f12")
         def _(event):
-            """When F12 is pressed, send 'proceed' as input immediately."""
+            """When F12 is pressed, rotate through a set of short instructions."""
             buf = event.app.current_buffer
-            buf.text = "proceed"
+            idx = _f12_index["value"]
+            buf.text = _f12_instructions[idx]
             buf.validate_and_handle()
+            _f12_index["value"] = (idx + 1) % len(_f12_instructions)
 
         style = Style.from_dict(
             {
@@ -50,7 +64,7 @@ class AskUserTool(ToolBase):
         )
 
         def get_toolbar():
-            f12_hint = " Press <b>F12</b> to auto-fill 'proceed' and submit."
+            f12_hint = ""
             if mode["multiline"]:
                 return HTML(
                     f"<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>{f12_hint}"

janito/agent/tools/create_directory.py

@@ -1,33 +1,65 @@
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
 from janito.agent.tool_base import ToolBase
+from janito.i18n import tr
+import os
 
 
 @register_tool(name="create_directory")
 class CreateDirectoryTool(ToolBase):
     """
-    Create a new directory at the specified path.
-
+    Create a new directory at the specified file_path.
     Args:
-        path (str): Path for the new directory.
-        overwrite (bool, optional): Whether to overwrite if the directory exists. Defaults to False.
+        file_path (str): Path for the new directory.
     Returns:
         str: Status message indicating the result. Example:
-            - "\u2705 Successfully created the directory at ..."
-            - "\u2757 Cannot create directory: ..."
+            - "✅ Successfully created the directory at ..."
+            - "❗ Cannot create directory: ..."
     """
 
-    def call(self, path: str, overwrite: bool = False) -> str:
-        original_path = path
-        path = expand_path(path)
-        disp_path = display_path(original_path, path)
-        import os
-
-        if os.path.exists(path):
-            if not os.path.isdir(path):
+    def run(self, file_path: str) -> str:
+        file_path = expand_path(file_path)
+        disp_path = display_path(file_path)
+        self.report_info(
+            tr("📁 Creating directory: '{disp_path}' ...", disp_path=disp_path)
+        )
+        try:
+            if os.path.exists(file_path):
+                if not os.path.isdir(file_path):
+                    self.report_error(
+                        tr(
+                            "❌ Path '{disp_path}' exists and is not a directory.",
+                            disp_path=disp_path,
+                        )
+                    )
+                    return tr(
+                        "❌ Path '{disp_path}' exists and is not a directory.",
+                        disp_path=disp_path,
+                    )
                 self.report_error(
-                    f"\u274c Path '{disp_path}' exists and is not a directory."
+                    tr(
+                        "❗ Directory '{disp_path}' already exists.",
+                        disp_path=disp_path,
+                    )
+                )
+                return tr(
+                    "❗ Cannot create directory: '{disp_path}' already exists.",
+                    disp_path=disp_path,
+                )
+            os.makedirs(file_path, exist_ok=True)
+            self.report_success(
+                tr("✅ Directory created at '{disp_path}'", disp_path=disp_path)
+            )
+            return tr(
+                "✅ Successfully created the directory at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+        except Exception as e:
+            self.report_error(
+                tr(
+                    "❌ Error creating directory '{disp_path}': {error}",
+                    disp_path=disp_path,
+                    error=e,
                 )
-                return f"\u274c Path '{disp_path}' exists and is not a directory."
-        # Directory creation logic would go here
-        return f"\u2705 Successfully created the directory at '{disp_path}'."
+            )
+            return tr("❌ Cannot create directory: {error}", error=e)

janito/agent/tools/create_file.py

@@ -3,45 +3,76 @@ import shutil
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
 from janito.agent.tool_base import ToolBase
-from janito.agent.tools.tools_utils import pluralize
+from janito.i18n import tr
 
 
 @register_tool(name="create_file")
 class CreateFileTool(ToolBase):
     """
-    Create a new file with the given content. Fails if the file already exists.
-
-    This tool will NOT overwrite existing files. If the file already exists, the operation fails and no changes are made to the file itself.
-
+    Create a new file with the given content, or overwrite if specified.
     Args:
-        path (str): Path to the file to create.
+        file_path (str): Path to the file to create or overwrite.
         content (str): Content to write to the file.
-        backup (bool, optional): If True, create a backup (.bak) before returning an error if the file exists. Defaults to False.
+        overwrite (bool, optional): If True, overwrite the file if it exists. Defaults to False.
+            CRITICAL: If you use overwrite=True, you MUST provide the full content for the file. Using placeholders or partial content will result in file corruption. Before overwriting, read the full original file.
     Returns:
         str: Status message indicating the result. Example:
-            - "\u2705 Successfully created the file at ..."
-            - "\u2757 Cannot create file: ..."
+            - "✅ Successfully created the file at ..."
     """
 
-    def call(self, path: str, content: str, backup: bool = False) -> str:
-        original_path = path
-        path = expand_path(path)
-        disp_path = display_path(original_path, path)
-        if os.path.exists(path):
-            if os.path.isdir(path):
-                self.report_error("\u274c Error: is a directory")
-                return f"\u274c Cannot create file: '{disp_path}' is an existing directory."
-            if backup:
-                shutil.copy2(path, path + ".bak")
-            self.report_error(f"\u2757 Error: file '{disp_path}' already exists")
-            return f"\u2757 Cannot create file: '{disp_path}' already exists."
-        # Ensure parent directories exist
-        dir_name = os.path.dirname(path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        self.report_info(f"\U0001f4dd Creating file: '{disp_path}' ... ")
-        with open(path, "w", encoding="utf-8", errors="replace") as f:
+    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
+        expanded_file_path = expand_path(file_path)
+        disp_path = display_path(expanded_file_path)
+        file_path = expanded_file_path
+        backup_path = None
+        if os.path.exists(file_path):
+            if not overwrite:
+                return tr(
+                    "⚠️ File already exists at '{disp_path}'. Use overwrite=True to overwrite.",
+                    disp_path=disp_path,
+                )
+            # Check ToolUseTracker for full read before overwrite
+            try:
+                from janito.agent.tool_use_tracker import ToolUseTracker
+
+                tracker = ToolUseTracker()
+                if not tracker.file_fully_read(file_path):
+                    self.report_error(
+                        "❌ Refusing to overwrite file: full file has not been read with get_lines."
+                    )
+                    return tr(
+                        "❌ Refusing to overwrite file: full file has not been read with get_lines."
+                    )
+            except Exception as e:
+                self.report_error(f"[ToolUseTracker] Error: {e}")
+                return tr("[ToolUseTracker] Error: {e}")
+            backup_path = file_path + ".bak"
+            shutil.copy2(file_path, backup_path)
+            self.report_info(
+                tr("📝 Updating file: '{disp_path}' ...", disp_path=disp_path)
+            )
+            mode = "w"
+            updated = True
+        else:
+            dir_name = os.path.dirname(file_path)
+            if dir_name:
+                os.makedirs(dir_name, exist_ok=True)
+            self.report_info(
+                tr("📝 Creating file: '{disp_path}' ...", disp_path=disp_path)
+            )
+            mode = "w"
+            updated = False
+        with open(file_path, mode, encoding="utf-8", errors="replace") as f:
             f.write(content)
         new_lines = content.count("\n") + 1 if content else 0
-        self.report_success(f"\u2705 {new_lines} {pluralize('line', new_lines)}")
-        return f"\u2705 Successfully created the file at '{disp_path}' ({new_lines} lines)."
+        if updated:
+            self.report_success(tr("✅ ({new_lines} lines).", new_lines=new_lines))
+            msg = tr(
+                "✅ Updated file ({new_lines} lines, backup at {backup_path}).",
+                new_lines=new_lines,
+                backup_path=backup_path,
+            )
+            return msg
+        else:
+            self.report_success(tr("✅ ({new_lines} lines).", new_lines=new_lines))
+            return tr("✅ Created file ({new_lines} lines).", new_lines=new_lines)

janito/agent/tools/dir_walk_utils.py

@@ -0,0 +1,16 @@
+import os
+from janito.agent.tools.gitignore_utils import filter_ignored
+
+
+def walk_dir_with_gitignore(root_dir, max_depth=0):
+    """
+    Walks the directory tree starting at root_dir, yielding (root, dirs, files) tuples,
+    with .gitignore rules applied. If max_depth > 0, limits recursion to that depth.
+    """
+    for root, dirs, files in os.walk(root_dir):
+        rel_path = os.path.relpath(root, root_dir)
+        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)
+        yield root, dirs, files

janito/agent/tools/fetch_url.py

@@ -1,15 +1,14 @@
 import requests
 from bs4 import BeautifulSoup
 from janito.agent.tool_registry import register_tool
-
 from janito.agent.tool_base import ToolBase
+from janito.i18n import tr
 
 
 @register_tool(name="fetch_url")
 class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
-
     Args:
         url (str): The URL of the web page to fetch.
         search_strings (list[str], optional): Strings to search for in the page content.
@@ -20,22 +19,23 @@ class FetchUrlTool(ToolBase):
             - "Warning: Empty URL provided. Operation skipped."
     """
 
-    def call(self, url: str, search_strings: list[str] = None) -> str:
+    def run(self, url: str, search_strings: list[str] = None) -> str:
         if not url.strip():
-            self.report_warning("⚠️ Warning: Empty URL provided. Operation skipped.")
-            return "Warning: Empty URL provided. Operation skipped."
-        self.report_info(f"🌐 Fetching URL: {url} ... ")
+            self.report_warning(tr("⚠️ Warning: Empty URL provided. Operation skipped."))
+            return tr("Warning: Empty URL provided. Operation skipped.")
+        self.report_info(tr("🌐 Fetching URL: {url} ...", url=url))
         response = requests.get(url, timeout=10)
         response.raise_for_status()
         self.update_progress(
             {
                 "event": "progress",
-                "message": f"Fetched URL with status {response.status_code}",
+                "message": tr(
+                    "Fetched URL with status {status}", status=response.status_code
+                ),
             }
         )
         soup = BeautifulSoup(response.text, "html.parser")
         text = soup.get_text(separator="\n")
-
         if search_strings:
             filtered = []
             for s in search_strings:
@@ -48,7 +48,6 @@ class FetchUrlTool(ToolBase):
             if filtered:
                 text = "\n...\n".join(filtered)
             else:
-                text = "No lines found for the provided search strings."
-
-        self.report_success("✅ Result")
+                text = tr("No lines found for the provided search strings.")
+        self.report_success(tr("✅ Result"))
         return text

janito/agent/tools/find_files.py

@@ -1,60 +1,69 @@
 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.tools_utils import pluralize, display_path
+from janito.agent.tools.dir_walk_utils import walk_dir_with_gitignore
+from janito.i18n import tr
 import fnmatch
-from janito.agent.tools.gitignore_utils import filter_ignored
+import os
 
 
 @register_tool(name="find_files")
 class FindFilesTool(ToolBase):
     """
     Find files in one or more directories matching a pattern. Respects .gitignore.
-
     Args:
-        directories (list[str]): List of directories to search in.
-        pattern (str): File pattern to match. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
-        recursive (bool, optional): Whether to search recursively in subdirectories. Defaults to False.
-        max_depth (int, optional): Maximum directory depth to search (0 = only top-level). If None, unlimited. Defaults to None.
+        paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory.
+        pattern (str): File pattern(s) to match. Multiple patterns can be separated by spaces. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
+        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).
+        max_results (int, optional): Maximum number of results to return. 0 means no limit (default).
     Returns:
         str: Newline-separated list of matching file paths. Example:
             "/path/to/file1.py\n/path/to/file2.py"
             "Warning: Empty file pattern provided. Operation skipped."
+            If max_results is reached, appends a note to the output.
     """
 
-    def call(
-        self,
-        directories: list[str],
-        pattern: str,
-        recursive: bool = False,
-        max_depth: int = None,
-    ) -> str:
-        import os
-
+    def run(self, paths: str, pattern: str, max_depth: int = 0) -> str:
         if not pattern:
             self.report_warning(
-                "⚠️ Warning: Empty file pattern provided. Operation skipped."
+                tr("⚠️  Warning: Empty file pattern provided. Operation skipped.")
             )
-            return "Warning: Empty file pattern provided. Operation skipped."
-        from janito.agent.tools.tools_utils import display_path
-
-        output = []
-        for directory in directories:
+            return tr("Warning: Empty file pattern provided. Operation skipped.")
+        output = set()
+        patterns = pattern.split()
+        for directory in paths.split():
             disp_path = display_path(directory)
-            self.report_info(f"🔍 Searching for files '{pattern}' in '{disp_path}'")
-            for root, dirs, files in os.walk(directory):
-                # Calculate depth
-                rel_path = os.path.relpath(root, directory)
-                depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
-                if max_depth is not None and depth > max_depth:
-                    # Prune traversal
-                    dirs[:] = []
-                    continue
-                if not recursive and depth > 0:
-                    # Only top-level if not recursive
-                    break
-                dirs, files = filter_ignored(root, dirs, files)
-                for filename in fnmatch.filter(files, pattern):
-                    output.append(os.path.join(root, filename))
-        self.report_success(f" ✅ {len(output)} {pluralize('file', len(output))} found")
-        return "\n".join(output)
+            depth_msg = (
+                tr(" (max depth: {max_depth})", max_depth=max_depth)
+                if max_depth > 0
+                else ""
+            )
+            self.report_info(
+                tr(
+                    "🔍 Searching for files '{pattern}' in '{disp_path}'{depth_msg} ...",
+                    pattern=pattern,
+                    disp_path=disp_path,
+                    depth_msg=depth_msg,
+                )
+            )
+            for root, dirs, files in walk_dir_with_gitignore(
+                directory, max_depth=max_depth
+            ):
+                for pat in patterns:
+                    for filename in fnmatch.filter(files, pat):
+                        output.add(os.path.join(root, filename))
+        self.report_success(
+            tr(
+                " ✅ {count} {file_word} found",
+                count=len(output),
+                file_word=pluralize("file", len(output)),
+            )
+        )
+        # If searching in '.', strip leading './' from results
+        if paths.strip() == ".":
+            output = {
+                p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
+                for p in output
+            }
+        result = "\n".join(sorted(output))
+        return result

janito/agent/tools/get_lines.py

@@ -1,13 +1,13 @@
 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
 
 
 @register_tool(name="get_lines")
 class GetLinesTool(ToolBase):
     """
     Read lines from a file. Returns specific lines if a range is provided, or the entire file if no range is given. If both from_line and to_line are None, the entire file is returned in one call—no need to chunk or split requests when reading the full file.
-
     Args:
         file_path (str): Path to the file to read lines from.
         from_line (int, optional): Starting line number (1-based). If None, starts from the first line.
@@ -20,15 +20,21 @@ class GetLinesTool(ToolBase):
             - "❗ not found"
     """
 
-    def call(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
+    def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
         from janito.agent.tools.tools_utils import display_path
 
         disp_path = display_path(file_path)
         if from_line and to_line:
-            self.report_info(f"📄 Reading {disp_path} lines {from_line}-{to_line}")
+            self.report_info(
+                tr(
+                    "📖 Reading {disp_path} {from_line}-{to_line}",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                )
+            )
         else:
-            self.report_info(f"📄 Reading {disp_path} (all lines)")
-
+            self.report_info(tr("📖 Reading {disp_path} all", disp_path=disp_path))
         try:
             with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()
@@ -37,40 +43,69 @@ class GetLinesTool(ToolBase):
             ]
             selected_len = len(selected)
             total_lines = len(lines)
+            at_end = False
             if from_line and to_line:
                 requested = to_line - from_line + 1
-                if selected_len < requested:
+                if to_line >= total_lines or selected_len < requested:
+                    at_end = True
+                if at_end:
                     self.report_success(
-                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
+                        tr(
+                            " ✅ {selected_len} {line_word} (end)",
+                            selected_len=selected_len,
+                            line_word=pluralize("line", selected_len),
+                        )
                     )
                 elif to_line < total_lines:
                     self.report_success(
-                        f" ✅ {selected_len} {pluralize('line', selected_len)} ({total_lines - to_line} lines to end)"
-                    )
-                else:
-                    self.report_success(
-                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
+                        tr(
+                            " ✅ {selected_len} {line_word} ({remaining} to eof)",
+                            selected_len=selected_len,
+                            line_word=pluralize("line", selected_len),
+                            remaining=total_lines - to_line,
+                        )
                     )
             else:
                 self.report_success(
-                    f" ✅ {selected_len} {pluralize('line', selected_len)} (full file)"
+                    tr(
+                        " ✅ {selected_len} {line_word}",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                    )
                 )
-            # Prepare header
             if from_line and to_line:
-                header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (of {total_lines})\n---\n"
-                if to_line >= total_lines:
-                    header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (end at line {total_lines})\n---\n"
+                if to_line >= total_lines or selected_len < (to_line - from_line + 1):
+                    header = tr(
+                        "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
+                        disp_path=disp_path,
+                        from_line=from_line,
+                        to_line=to_line,
+                    )
+                else:
+                    header = tr(
+                        "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
+                        disp_path=disp_path,
+                        from_line=from_line,
+                        to_line=to_line,
+                        total_lines=total_lines,
+                    )
             elif from_line:
-                header = f"---\nFile: {disp_path} | Lines: {from_line}-END (of {total_lines})\n---\n"
-                header = f"---\nFile: {disp_path} | Lines: {from_line}-END (end at line {total_lines})\n---\n"
+                header = tr(
+                    "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    total_lines=total_lines,
+                )
             else:
-                header = (
-                    f"---\nFile: {disp_path} | All lines (total: {total_lines})\n---\n"
+                header = tr(
+                    "---\n{disp_path} All lines (total: {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    total_lines=total_lines,
                 )
             return header + "".join(selected)
         except Exception as e:
             if isinstance(e, FileNotFoundError):
-                self.report_error("❗ not found")
-                return "❗ not found"
-            self.report_error(f" ❌ Error: {e}")
-            return f"Error reading file: {e}"
+                self.report_error(tr("❗ not found"))
+                return tr("❗ not found")
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)

janito/agent/tools/memory.py

@@ -0,0 +1,48 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+
+
+@register_tool(name="memory")
+class MemoryTool(ToolBase):
+    """
+    Simple in-memory key-value store for demonstration purposes.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.memory = {}
+
+    def run(self, action: str, key: str, value: str = None) -> str:
+        if action == "set":
+            self.report_info(tr("ℹ️ Storing value for key: '{key}' ...", key=key))
+            self.memory[key] = value
+            msg = tr("Value stored for key: '{key}'.", key=key)
+            self.report_success(msg)
+            return msg
+        elif action == "get":
+            self.report_info(tr("ℹ️ Retrieving value for key: '{key}' ...", key=key))
+            if key in self.memory:
+                msg = tr(
+                    "Value for key '{key}': {value}", key=key, value=self.memory[key]
+                )
+                self.report_success(msg)
+                return msg
+            else:
+                msg = tr("Key '{key}' not found.", key=key)
+                self.report_warning(msg)
+                return msg
+        elif action == "delete":
+            if key in self.memory:
+                del self.memory[key]
+                msg = tr("Key '{key}' deleted.", key=key)
+                self.report_success(msg)
+                return msg
+            else:
+                msg = tr("Key '{key}' not found.", key=key)
+                self.report_error(msg)
+                return msg
+        else:
+            msg = tr("Unknown action: {action}", action=action)
+            self.report_error(msg)
+            return msg