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

janito/agent/tools/memory.py

@@ -1,68 +1,48 @@
-"""
-In-memory memory tools for storing and retrieving reusable information during an agent session.
-These tools allow the agent to remember and recall arbitrary key-value pairs for the duration of the process.
-"""
-
 from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
-# Simple in-memory store (process-local, not persistent)
-_memory_store = {}
+from janito.i18n import tr
 
 
-@register_tool(name="store_memory")
-class StoreMemoryTool(ToolBase):
+@register_tool(name="memory")
+class MemoryTool(ToolBase):
     """
-    Store a value for later retrieval using a key. Use this tool to remember information that may be useful in future steps or requests.
-
-    Args:
-        key (str): The identifier for the value to store.
-        value (str): The value to store for later retrieval.
-    Returns:
-        str: Status message indicating success or error. Example:
-            - "✅ Stored value for key: 'foo'"
-            - "❗ Error storing value: ..."
+    Simple in-memory key-value store for demonstration purposes.
     """
 
-    def call(self, key: str, value: str) -> str:
-        self.report_info(f"Storing value for key: '{key}'")
-        try:
-            _memory_store[key] = value
-            msg = f"✅ Stored value for key: '{key}'"
+    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
-        except Exception as e:
-            msg = f"❗ Error storing value: {e}"
-            self.report_error(msg)
-            return msg
-
-
-@register_tool(name="retrieve_memory")
-class RetrieveMemoryTool(ToolBase):
-    """
-    Retrieve a value previously stored using a key. Use this tool to recall information remembered earlier in the session.
-
-    Args:
-        key (str): The identifier for the value to retrieve.
-    Returns:
-        str: The stored value, or a warning message if not found. Example:
-            - "🔎 Retrieved value for key: 'foo': bar"
-            - "⚠️ No value found for key: 'notfound'"
-    """
-
-    def call(self, key: str) -> str:
-        self.report_info(f"Retrieving value for key: '{key}'")
-        try:
-            if key in _memory_store:
-                value = _memory_store[key]
-                msg = f"🔎 Retrieved value for key: '{key}': {value}"
+        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 = f"⚠️ No value found for key: '{key}'"
+                msg = tr("Key '{key}' not found.", key=key)
                 self.report_warning(msg)
                 return msg
-        except Exception as e:
-            msg = f"❗ Error retrieving value: {e}"
+        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

janito/agent/tools/move_file.py

@@ -3,23 +3,24 @@ 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.i18n import tr
 
 
 @register_tool(name="move_file")
 class MoveFileTool(ToolBase):
     """
-    Move a file from src_path to dest_path.
+    Move a file or directory from src_path to dest_path.
 
     Args:
-        src_path (str): Source file path.
-        dest_path (str): Destination file path.
+        src_path (str): Source file or directory path.
+        dest_path (str): Destination file or directory path.
         overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
-        backup (bool, optional): If True, create a backup (.bak) of the destination before moving if it exists. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): If True, create a backup (.bak for files, .bak.zip for directories) of the destination before moving if it exists. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
     Returns:
         str: Status message indicating the result.
     """
 
-    def call(
+    def run(
         self,
         src_path: str,
         dest_path: str,
@@ -30,30 +31,78 @@ class MoveFileTool(ToolBase):
         original_dest = dest_path
         src = expand_path(src_path)
         dest = expand_path(dest_path)
-        disp_src = display_path(original_src, src)
-        disp_dest = display_path(original_dest, dest)
-
+        disp_src = display_path(original_src)
+        disp_dest = display_path(original_dest)
+        backup_path = None
         if not os.path.exists(src):
-            self.report_error(f"\u274c Source file '{disp_src}' does not exist.")
-            return f"\u274c Source file '{disp_src}' does not exist."
-        if not os.path.isfile(src):
-            self.report_error(f"\u274c Source path '{disp_src}' is not a file.")
-            return f"\u274c Source path '{disp_src}' is not a file."
+            self.report_error(
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+            )
+            return tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+        is_src_file = os.path.isfile(src)
+        is_src_dir = os.path.isdir(src)
+        if not (is_src_file or is_src_dir):
+            self.report_error(
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                )
+            )
+            return tr(
+                "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                disp_src=disp_src,
+            )
         if os.path.exists(dest):
             if not overwrite:
                 self.report_error(
-                    f"\u2757 Destination '{disp_dest}' exists and overwrite is False."
+                    tr(
+                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
+                        disp_dest=disp_dest,
+                    )
+                )
+                return tr(
+                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
+                    disp_dest=disp_dest,
                 )
-                return f"\u2757 Destination '{disp_dest}' already exists and overwrite is False."
-            if os.path.isdir(dest):
-                self.report_error(f"\u274c Destination '{disp_dest}' is a directory.")
-                return f"\u274c Destination '{disp_dest}' is a directory."
             if backup:
-                shutil.copy2(dest, dest + ".bak")
+                if os.path.isfile(dest):
+                    backup_path = dest + ".bak"
+                    shutil.copy2(dest, backup_path)
+                elif os.path.isdir(dest):
+                    backup_path = dest.rstrip("/\\") + ".bak.zip"
+                    shutil.make_archive(dest.rstrip("/\\") + ".bak", "zip", dest)
+            try:
+                if os.path.isfile(dest):
+                    os.remove(dest)
+                elif os.path.isdir(dest):
+                    shutil.rmtree(dest)
+            except Exception as e:
+                self.report_error(
+                    tr("❌ Error removing destination before move: {error}", error=e)
+                )
+                return tr("❌ Error removing destination before move: {error}", error=e)
         try:
             shutil.move(src, dest)
-            self.report_success(f"\u2705 File moved from '{disp_src}' to '{disp_dest}'")
-            return f"\u2705 Successfully moved the file from '{disp_src}' to '{disp_dest}'."
+            self.report_success(
+                tr(
+                    "✅ Moved 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,
+            )
+            if backup_path:
+                msg += tr(
+                    " (backup at {backup_disp})",
+                    backup_disp=display_path(
+                        original_dest + (".bak" if is_src_file else ".bak.zip")
+                    ),
+                )
+            return msg
         except Exception as e:
-            self.report_error(f"\u274c Error moving file: {e}")
-            return f"\u274c Error moving file: {e}"
+            self.report_error(tr("❌ Error moving: {error}", error=e))
+            return tr("❌ Error moving: {error}", error=e)

janito/agent/tools/outline_file/__init__.py

@@ -0,0 +1,85 @@
+from janito.agent.tool_registry import register_tool
+from .python_outline import parse_python_outline
+from .markdown_outline import parse_markdown_outline
+from .formatting import format_outline_table, format_markdown_outline_table
+import os
+from janito.agent.tool_base import ToolBase
+from janito.agent.tools.tools_utils import display_path
+from janito.i18n import tr
+
+
+@register_tool(name="outline_file")
+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.
+    """
+
+    def run(self, file_path: str) -> str:
+        try:
+            self.report_info(
+                tr(
+                    "📄 Outlining file: '{disp_path}' ...",
+                    disp_path=display_path(file_path),
+                )
+            )
+            ext = os.path.splitext(file_path)[1].lower()
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+            if ext == ".py":
+                outline_items = parse_python_outline(lines)
+                outline_type = "python"
+                table = format_outline_table(outline_items)
+                self.report_success(
+                    tr(
+                        "✅ {count} items ({outline_type})",
+                        count=len(outline_items),
+                        outline_type=outline_type,
+                    )
+                )
+                return (
+                    tr(
+                        "Outline: {count} items ({outline_type})\n",
+                        count=len(outline_items),
+                        outline_type=outline_type,
+                    )
+                    + table
+                )
+            elif ext == ".md":
+                outline_items = parse_markdown_outline(lines)
+                outline_type = "markdown"
+                table = format_markdown_outline_table(outline_items)
+                self.report_success(
+                    tr(
+                        "✅ {count} items ({outline_type})",
+                        count=len(outline_items),
+                        outline_type=outline_type,
+                    )
+                )
+                return (
+                    tr(
+                        "Outline: {count} items ({outline_type})\n",
+                        count=len(outline_items),
+                        outline_type=outline_type,
+                    )
+                    + table
+                )
+            else:
+                outline_type = "default"
+                self.report_success(
+                    tr(
+                        "✅ {count} lines ({outline_type})",
+                        count=len(lines),
+                        outline_type=outline_type,
+                    )
+                )
+                return tr(
+                    "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
+                    count=len(lines),
+                    outline_type=outline_type,
+                )
+        except Exception as e:
+            self.report_error(tr("❌ Error reading file: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)

janito/agent/tools/outline_file/formatting.py

@@ -0,0 +1,20 @@
+def format_outline_table(outline_items):
+    if not outline_items:
+        return "No classes, functions, or variables found."
+    header = "| Type    | Name        | Start | End | Parent   |\n|---------|-------------|-------|-----|----------|"
+    rows = []
+    for item in outline_items:
+        rows.append(
+            f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} |"
+        )
+    return header + "\n" + "\n".join(rows)
+
+
+def format_markdown_outline_table(outline_items):
+    if not outline_items:
+        return "No headers found."
+    header = "| Level | Header                          | Line |\n|-------|----------------------------------|------|"
+    rows = []
+    for item in outline_items:
+        rows.append(f"| {item['level']:<5} | {item['title']:<32} | {item['line']:<4} |")
+    return header + "\n" + "\n".join(rows)

janito/agent/tools/outline_file/markdown_outline.py

@@ -0,0 +1,14 @@
+import re
+from typing import List
+
+
+def parse_markdown_outline(lines: List[str]):
+    header_pat = re.compile(r"^(#+)\s+(.*)")
+    outline = []
+    for idx, line in enumerate(lines):
+        match = header_pat.match(line)
+        if match:
+            level = len(match.group(1))
+            title = match.group(2).strip()
+            outline.append({"level": level, "title": title, "line": idx + 1})
+    return outline

janito/agent/tools/outline_file/python_outline.py

@@ -0,0 +1,71 @@
+import re
+from typing import List
+
+
+def parse_python_outline(lines: List[str]):
+    class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+    func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+    assign_pat = re.compile(r"^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=.*")
+    outline = []
+    stack = []  # (type, name, indent, start, parent)
+    for idx, line in enumerate(lines):
+        class_match = class_pat.match(line)
+        func_match = func_pat.match(line)
+        assign_match = assign_pat.match(line)
+        indent = len(line) - len(line.lstrip())
+        if class_match:
+            name = class_match.group(2)
+            parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+            stack.append(("class", name, indent, idx + 1, parent))
+        elif func_match:
+            name = func_match.group(2)
+            parent = (
+                stack[-1][1]
+                if stack
+                and stack[-1][0] in ("class", "function")
+                and indent > stack[-1][2]
+                else ""
+            )
+            stack.append(("function", name, indent, idx + 1, parent))
+        elif assign_match and indent == 0:
+            var_name = assign_match.group(2)
+            var_type = "const" if var_name.isupper() else "var"
+            outline.append(
+                {
+                    "type": var_type,
+                    "name": var_name,
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                }
+            )
+        while stack and indent < stack[-1][2]:
+            popped = stack.pop()
+            outline.append(
+                {
+                    "type": (
+                        popped[0]
+                        if popped[0] != "function" or popped[3] == 1
+                        else ("method" if popped[4] else "function")
+                    ),
+                    "name": popped[1],
+                    "start": popped[3],
+                    "end": idx,
+                    "parent": popped[4],
+                }
+            )
+    for popped in stack:
+        outline.append(
+            {
+                "type": (
+                    popped[0]
+                    if popped[0] != "function" or popped[3] == 1
+                    else ("method" if popped[4] else "function")
+                ),
+                "name": popped[1],
+                "start": popped[3],
+                "end": len(lines),
+                "parent": popped[4],
+            }
+        )
+    return outline

janito/agent/tools/present_choices.py

@@ -0,0 +1,62 @@
+from typing import List
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+import questionary
+from questionary import Style
+
+custom_style = Style(
+    [
+        ("pointer", "fg:#ffffff bg:#1976d2 bold"),
+        ("highlighted", "fg:#ffffff bg:#1565c0 bold"),
+        ("answer", "fg:#1976d2 bold"),
+        ("qmark", "fg:#1976d2 bold"),
+    ]
+)
+HAND_EMOJI = "🖐️"  # 🖐️
+
+
+@register_tool(name="present_choices")
+class PresentChoicesTool(ToolBase):
+    """
+    Present a list of options to the user and return the selected option(s).
+
+    Args:
+        prompt (str): The prompt/question to display.
+        choices (List[str]): List of options to present. Use \n in option text for explicit line breaks if needed.
+        multi_select (bool): If True, allow multiple selections.
+    Returns:
+        str: The selected option(s) as a string, or a message if cancelled.
+            - For multi_select=True, returns each selection on a new line, each prefixed with '- '.
+            - For multi_select=False, returns the selected option as a string.
+            - If cancelled, returns 'No selection made.'
+    """
+
+    def run(self, prompt: str, choices: List[str], multi_select: bool = False) -> str:
+        if not choices:
+            return tr("⚠️ No choices provided.")
+        self.report_info(
+            tr(
+                "ℹ️ Prompting user: {prompt} (multi_select={multi_select}) ...",
+                prompt=prompt,
+                multi_select=multi_select,
+            )
+        )
+        if multi_select:
+            result = questionary.checkbox(
+                prompt, choices=choices, style=custom_style, pointer=HAND_EMOJI
+            ).ask()
+            if result is None:
+                return tr("No selection made.")
+            return (
+                "\n".join(f"- {item}" for item in result)
+                if isinstance(result, list)
+                else f"- {result}"
+            )
+        else:
+            result = questionary.select(
+                prompt, choices=choices, style=custom_style, pointer=HAND_EMOJI
+            ).ask()
+            if result is None:
+                return tr("No selection made.")
+            return str(result)

janito/agent/tools/present_choices_test.py

@@ -0,0 +1,18 @@
+"""
+Test for present_choices tool.
+
+Note: This test is for manual/interactive verification only, as prompt_toolkit dialogs require user interaction.
+"""
+
+from present_choices import present_choices
+
+if __name__ == "__main__":
+    prompt = "Select your favorite fruits:"
+    choices = ["Apple", "Banana", "Cherry", "Date"]
+    print("Single-select test:")
+    selected = present_choices(prompt, choices, multi_select=False)
+    print(f"Selected: {selected}")
+
+    print("\nMulti-select test:")
+    selected_multi = present_choices(prompt, choices, multi_select=True)
+    print(f"Selected: {selected_multi}")

janito/agent/tools/remove_directory.py

@@ -1,7 +1,7 @@
 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.i18n import tr
 import shutil
 import os
 import zipfile
@@ -10,41 +10,46 @@ import zipfile
 @register_tool(name="remove_directory")
 class RemoveDirectoryTool(ToolBase):
     """
-    Remove a directory. If recursive=False and directory not empty, raises error.
+    Remove a directory.
 
     Args:
-        directory (str): Path to the directory to remove.
-        recursive (bool, optional): Remove recursively if True. Defaults to False.
-        backup (bool, optional): If True, create a backup (.bak.zip) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        file_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:
             - "Directory removed: /path/to/dir"
             - "Error removing directory: <error message>"
     """
 
-    def call(
-        self, directory: str, recursive: bool = False, backup: bool = False
-    ) -> str:
+    def run(self, file_path: str, recursive: bool = False) -> str:
+        disp_path = display_path(file_path)
         self.report_info(
-            f"\U0001f5c3\ufe0f  Removing directory: {directory} (recursive={recursive})"
+            tr("🗃️  Removing directory: {disp_path} ...", disp_path=disp_path)
         )
+        backup_zip = None
         try:
-            if backup and os.path.exists(directory) and os.path.isdir(directory):
-                backup_zip = directory.rstrip("/\\") + ".bak.zip"
-                with zipfile.ZipFile(backup_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
-                    for root, dirs, files in os.walk(directory):
-                        for file in files:
-                            abs_path = os.path.join(root, file)
-                            rel_path = os.path.relpath(
-                                abs_path, os.path.dirname(directory)
-                            )
-                            zipf.write(abs_path, rel_path)
             if recursive:
-                shutil.rmtree(directory)
+                # Backup before recursive removal
+                if os.path.exists(file_path) and os.path.isdir(file_path):
+                    backup_zip = file_path.rstrip("/\\") + ".bak.zip"
+                    with zipfile.ZipFile(backup_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
+                        for root, dirs, files in os.walk(file_path):
+                            for file in files:
+                                abs_path = os.path.join(root, file)
+                                rel_path = os.path.relpath(
+                                    abs_path, os.path.dirname(file_path)
+                                )
+                                zipf.write(abs_path, rel_path)
+                shutil.rmtree(file_path)
             else:
-                os.rmdir(directory)
-            self.report_success(f"\u2705 1 {pluralize('directory', 1)}")
-            return f"Directory removed: {directory}"
+                os.rmdir(file_path)
+            self.report_success(
+                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1))
+            )
+            msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
+            if backup_zip:
+                msg += tr(" (backup at {backup_zip})", backup_zip=backup_zip)
+            return msg
         except Exception as e:
-            self.report_error(f" \u274c Error removing directory: {e}")
-            return f"Error removing directory: {e}"
+            self.report_error(tr(" ❌ Error removing directory: {error}", error=e))
+            return tr("Error removing directory: {error}", error=e)

janito/agent/tools/remove_file.py

@@ -3,6 +3,7 @@ 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.i18n import tr
 
 
 @register_tool(name="remove_file")
@@ -15,26 +16,43 @@ class RemoveFileTool(ToolBase):
         backup (bool, optional): If True, create a backup (.bak) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
     Returns:
         str: Status message indicating the result. Example:
-            - "\u2705 Successfully removed the file at ..."
-            - "\u2757 Cannot remove file: ..."
+            - "✅ Successfully removed the file at ..."
+            - "❗ Cannot remove file: ..."
     """
 
-    def call(self, file_path: str, backup: bool = False) -> str:
+    def run(self, file_path: str, backup: bool = False) -> str:
         original_path = file_path
         path = expand_path(file_path)
-        disp_path = display_path(original_path, path)
+        disp_path = display_path(original_path)
+        backup_path = None
         if not os.path.exists(path):
-            self.report_error(f"\u274c File '{disp_path}' does not exist.")
-            return f"\u274c File '{disp_path}' does not exist."
+            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)
         if not os.path.isfile(path):
-            self.report_error(f"\u274c Path '{disp_path}' is not a file.")
-            return f"\u274c Path '{disp_path}' is not a file."
+            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)
         try:
             if backup:
-                shutil.copy2(path, path + ".bak")
+                backup_path = path + ".bak"
+                shutil.copy2(path, backup_path)
             os.remove(path)
-            self.report_success(f"\u2705 File removed: '{disp_path}'")
-            return f"\u2705 Successfully removed the file at '{disp_path}'."
+            self.report_success(
+                tr("✅ File removed: '{disp_path}'", disp_path=disp_path)
+            )
+            msg = tr(
+                "✅ Successfully removed the file at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+            if backup_path:
+                msg += tr(
+                    " (backup at {backup_disp})",
+                    backup_disp=display_path(original_path + ".bak"),
+                )
+            return msg
         except Exception as e:
-            self.report_error(f"\u274c Error removing file: {e}")
-            return f"\u274c Error removing file: {e}"
+            self.report_error(tr("❌ Error removing file: {error}", error=e))
+            return tr("❌ Error removing file: {error}", error=e)