janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/tools/create_file.py

@@ -1,78 +1,59 @@
 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.agent.tools_utils.action_type import ActionType
 from janito.i18n import tr
 
 
+from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
+
+
 @register_tool(name="create_file")
 class CreateFileTool(ToolBase):
     """
-    Create a new file with the given content, or overwrite if specified.
+    Create a new file with the given content.
     Args:
-        file_path (str): Path to the file to create or overwrite.
+        file_path (str): Path to the file to create.
         content (str): Content to write to the file.
-        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:
             - "✅ Successfully created the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
     """
 
-    def run(self, file_path: str, content: str, overwrite: bool = False) -> str:
-        expanded_file_path = expand_path(file_path)
+    def run(self, file_path: str, content: str) -> str:
+        expanded_file_path = file_path  # Using file_path as is
         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."
-                    )
+                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                    existing_content = f.read()
             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)
+                existing_content = f"[Error reading file: {e}]"
+            return tr(
+                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
+                disp_path=disp_path,
+                existing_content=existing_content,
             )
-            mode = "w"
-            updated = False
-        with open(file_path, mode, encoding="utf-8", errors="replace") as f:
+        dir_name = os.path.dirname(file_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        self.report_info(
+            ActionType.WRITE,
+            tr("📝 Creating file '{disp_path}' ...", disp_path=disp_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
-        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)
+        self.report_success(tr("✅ {new_lines} lines", new_lines=new_lines))
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(file_path)
+        return (
+            tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
+            + f"\n{validation_result}"
+        )

janito/agent/tools/delete_text_in_file.py

@@ -0,0 +1,97 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+from janito.i18n import tr
+
+
+@register_tool(name="delete_text_in_file")
+class DeleteTextInFileTool(ToolBase):
+    """
+    Delete all occurrences of text between start_marker and end_marker (inclusive) in a file, using exact string markers.
+
+    Args:
+        file_path (str): Path to the file to modify.
+        start_marker (str): The starting delimiter string.
+        end_marker (str): The ending delimiter string.
+        backup (bool, optional): If True, create a backup (.bak) before deleting. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    def run(
+        self,
+        file_path: str,
+        start_marker: str,
+        end_marker: str,
+        backup: bool = False,
+    ) -> str:
+        import shutil
+        from janito.agent.tools_utils.utils import display_path
+
+        disp_path = display_path(file_path)
+        backup_path = file_path + ".bak"
+        backup_msg = ""
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except Exception as e:
+            self.report_error(tr(" ❌ Error reading file: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
+
+        start_count = content.count(start_marker)
+        if start_count > 1:
+            self.report_error("Need more context for start_marker")
+            return (
+                f"Error: start_marker is not unique in {disp_path}. "
+                "Try including the next line(s) for more context."
+            )
+
+        end_count = content.count(end_marker)
+        if end_count > 1:
+            self.report_error("Need more context for end_marker")
+            return (
+                f"Error: end_marker is not unique in {disp_path}. "
+                "Try including the previous line(s) for more context."
+            )
+
+        count = 0
+        new_content = content
+        while True:
+            start_idx = new_content.find(start_marker)
+            if start_idx == -1:
+                break
+            end_idx = new_content.find(end_marker, start_idx + len(start_marker))
+            if end_idx == -1:
+                break
+            # Remove from start_marker to end_marker (inclusive)
+            new_content = (
+                new_content[:start_idx] + new_content[end_idx + len(end_marker) :]
+            )
+            count += 1
+
+        if count == 0:
+            self.report_warning(tr("ℹ️ No blocks found between markers."))
+            return tr(
+                "No blocks found between markers in {file_path}.", file_path=file_path
+            )
+
+        if backup:
+            shutil.copy2(file_path, backup_path)
+            backup_msg = f" (A backup was saved to {backup_path})"
+        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(new_content)
+
+        self.report_success(
+            tr(
+                "Deleted {count} block(s) between markers in {disp_path}.",
+                count=count,
+                disp_path=disp_path,
+            )
+        )
+        return (
+            tr(
+                "Deleted {count} block(s) between markers in {file_path}.",
+                count=count,
+                file_path=file_path,
+            )
+            + backup_msg
+        )

janito/agent/tools/fetch_url.py

@@ -2,7 +2,9 @@ import requests
 from bs4 import BeautifulSoup
 from janito.agent.tool_registry import register_tool
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.i18n import tr
+from janito.agent.tools_utils.utils import pluralize
 
 
 @register_tool(name="fetch_url")
@@ -21,11 +23,47 @@ class FetchUrlTool(ToolBase):
 
     def run(self, url: str, search_strings: list[str] = None) -> str:
         if not url.strip():
-            self.report_warning(tr("⚠️ Warning: Empty URL provided. Operation skipped."))
+            self.report_warning(tr("ℹ️ Empty URL provided."))
             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.report_info(ActionType.READ, tr("🌐 Fetching URL '{url}' ...", url=url))
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as http_err:
+            status_code = http_err.response.status_code if http_err.response else None
+            if status_code and 400 <= status_code < 500:
+                self.report_error(
+                    tr(
+                        "❗ HTTP {status_code} error for URL: {url}",
+                        status_code=status_code,
+                        url=url,
+                    )
+                )
+                return tr(
+                    "Warning: HTTP {status_code} error for URL: {url}",
+                    status_code=status_code,
+                    url=url,
+                )
+            else:
+                self.report_error(
+                    tr(
+                        "❗ HTTP error for URL: {url}: {err}",
+                        url=url,
+                        err=str(http_err),
+                    )
+                )
+                return tr(
+                    "Warning: HTTP error for URL: {url}: {err}",
+                    url=url,
+                    err=str(http_err),
+                )
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err))
+            )
+            return tr(
+                "Warning: Error fetching URL: {url}: {err}", url=url, err=str(err)
+            )
         self.update_progress(
             {
                 "event": "progress",
@@ -49,5 +87,12 @@ class FetchUrlTool(ToolBase):
                 text = "\n...\n".join(filtered)
             else:
                 text = tr("No lines found for the provided search strings.")
-        self.report_success(tr("✅ Result"))
+        num_lines = len(text.splitlines())
+        self.report_success(
+            tr(
+                "✅ {num_lines} {line_word}",
+                num_lines=num_lines,
+                line_word=pluralize("line", num_lines),
+            )
+        )
         return text

janito/agent/tools/find_files.py

@@ -1,7 +1,8 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.tools_utils import pluralize, display_path
-from janito.agent.tools.dir_walk_utils import walk_dir_with_gitignore
+from janito.agent.tools_utils.utils import pluralize, display_path
+from janito.agent.tools_utils.dir_walk_utils import walk_dir_with_gitignore
 from janito.i18n import tr
 import fnmatch
 import os
@@ -10,11 +11,12 @@ import os
 @register_tool(name="find_files")
 class FindFilesTool(ToolBase):
     """
-    Find files in one or more directories matching a pattern. Respects .gitignore.
+    Find files or directories in one or more directories matching a pattern. Respects .gitignore.
     Args:
         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).
+            - If the pattern ends with '/' or '\\', only matching directory names (with trailing slash) are returned, not the files within those directories. For example, pattern '*/' will return only directories at the specified depth.
+        max_depth (int, optional): Maximum directory depth to search. If None, unlimited recursion. If 0, only the top-level directory. If 1, only the root directory (matches 'find . -maxdepth 1').
         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:
@@ -23,47 +25,59 @@ class FindFilesTool(ToolBase):
             If max_results is reached, appends a note to the output.
     """
 
-    def run(self, paths: str, pattern: str, max_depth: int = 0) -> str:
+    def run(self, paths: str, pattern: str, max_depth: int = None) -> str:
         if not pattern:
-            self.report_warning(
-                tr("⚠️  Warning: Empty file pattern provided. Operation skipped.")
-            )
+            self.report_warning(tr("ℹ️ Empty file pattern provided."))
             return tr("Warning: Empty file pattern provided. Operation skipped.")
-        output = set()
         patterns = pattern.split()
+        results = []
         for directory in paths.split():
             disp_path = display_path(directory)
             depth_msg = (
                 tr(" (max depth: {max_depth})", max_depth=max_depth)
-                if max_depth > 0
+                if max_depth is not None and max_depth > 0
                 else ""
             )
             self.report_info(
+                ActionType.READ,
                 tr(
                     "🔍 Searching for files '{pattern}' in '{disp_path}'{depth_msg} ...",
                     pattern=pattern,
                     disp_path=disp_path,
                     depth_msg=depth_msg,
-                )
+                ),
             )
+            dir_output = set()
             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)),
+                    # Directory matching: pattern ends with '/' or '\'
+                    if pat.endswith("/") or pat.endswith("\\"):
+                        dir_pat = pat.rstrip("/\\")
+                        for d in dirs:
+                            if fnmatch.fnmatch(d, dir_pat):
+                                dir_output.add(os.path.join(root, d) + os.sep)
+                    else:
+                        # Match files
+                        for filename in fnmatch.filter(files, pat):
+                            dir_output.add(os.path.join(root, filename))
+                        # Also match directories (without trailing slash)
+                        for d in fnmatch.filter(dirs, pat):
+                            dir_output.add(os.path.join(root, d))
+            self.report_success(
+                tr(
+                    " ✅ {count} {file_word}",
+                    count=len(dir_output),
+                    file_word=pluralize("file", len(dir_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))
+            # If searching in '.', strip leading './' from results
+            if directory.strip() == ".":
+                dir_output = {
+                    p[2:] if (p.startswith("./") or p.startswith(".\\")) else p
+                    for p in dir_output
+                }
+            results.extend(sorted(dir_output))
+        result = "\n".join(results)
         return result

janito/agent/tools/get_file_outline/__init__.py

@@ -0,0 +1 @@
+# Outline tools and parsers package

janito/agent/tools/{outline_file/__init__.py → get_file_outline/core.py}

@@ -1,14 +1,15 @@
 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
+from janito.agent.tools_utils.formatting import OutlineFormatter
 import os
 from janito.agent.tool_base import ToolBase
-from janito.agent.tools.tools_utils import display_path
+from janito.agent.tools_utils.action_type import ActionType
+from janito.agent.tools_utils.utils import display_path, pluralize
 from janito.i18n import tr
 
 
-@register_tool(name="outline_file")
+@register_tool(name="get_file_outline")
 class GetFileOutlineTool(ToolBase):
     """
     Get an outline of a file's structure. Supports Python and Markdown files.
@@ -20,10 +21,11 @@ class GetFileOutlineTool(ToolBase):
     def run(self, file_path: str) -> str:
         try:
             self.report_info(
+                ActionType.READ,
                 tr(
-                    "📄 Outlining file: '{disp_path}' ...",
+                    "📄 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:
@@ -31,12 +33,12 @@ class GetFileOutlineTool(ToolBase):
             if ext == ".py":
                 outline_items = parse_python_outline(lines)
                 outline_type = "python"
-                table = format_outline_table(outline_items)
+                table = OutlineFormatter.format_outline_table(outline_items)
                 self.report_success(
                     tr(
-                        "✅ {count} items ({outline_type})",
+                        "✅ Outlined {count} {item_word}",
                         count=len(outline_items),
-                        outline_type=outline_type,
+                        item_word=pluralize("item", len(outline_items)),
                     )
                 )
                 return (
@@ -50,12 +52,12 @@ class GetFileOutlineTool(ToolBase):
             elif ext == ".md":
                 outline_items = parse_markdown_outline(lines)
                 outline_type = "markdown"
-                table = format_markdown_outline_table(outline_items)
+                table = OutlineFormatter.format_markdown_outline_table(outline_items)
                 self.report_success(
                     tr(
-                        "✅ {count} items ({outline_type})",
+                        "✅ Outlined {count} {item_word}",
                         count=len(outline_items),
-                        outline_type=outline_type,
+                        item_word=pluralize("item", len(outline_items)),
                     )
                 )
                 return (
@@ -68,13 +70,7 @@ class GetFileOutlineTool(ToolBase):
                 )
             else:
                 outline_type = "default"
-                self.report_success(
-                    tr(
-                        "✅ {count} lines ({outline_type})",
-                        count=len(lines),
-                        outline_type=outline_type,
-                    )
-                )
+                self.report_success(tr("✅ Outlined {count} items", count=len(lines)))
                 return tr(
                     "Outline: {count} lines ({outline_type})\nFile has {count} lines.",
                     count=len(lines),

janito/agent/tools/get_file_outline/python_outline.py

@@ -0,0 +1,134 @@
+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*=.*")
+    main_pat = re.compile(r"^\s*if\s+__name__\s*==\s*[\'\"]__main__[\'\"]\s*:")
+    outline = []
+    stack = []  # (type, name, indent, start, parent)
+    obj_ranges = []  # (type, name, start, end, parent, indent)
+    last_top_obj = None
+    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 a new top-level class or function starts, close the previous one
+        if (class_match or func_match) and indent == 0 and last_top_obj:
+            # Only close if still open
+            if last_top_obj in stack:
+                stack.remove(last_top_obj)
+                obj_ranges.append(
+                    (
+                        last_top_obj[0],
+                        last_top_obj[1],
+                        last_top_obj[3],
+                        idx,
+                        last_top_obj[4],
+                        last_top_obj[2],
+                    )
+                )
+            last_top_obj = None
+        if class_match:
+            name = class_match.group(2)
+            parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+            obj = ("class", name, indent, idx + 1, parent)
+            stack.append(obj)
+            if indent == 0:
+                last_top_obj = obj
+        elif func_match:
+            name = func_match.group(2)
+            parent = ""
+            for s in reversed(stack):
+                if s[0] == "class" and indent > s[2]:
+                    parent = s[1]
+                    break
+            obj = ("function", name, indent, idx + 1, parent)
+            stack.append(obj)
+            if indent == 0:
+                last_top_obj = obj
+        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": "",
+                    "docstring": "",
+                }
+            )
+        main_match = main_pat.match(line)
+        if main_match:
+            outline.append(
+                {
+                    "type": "main",
+                    "name": "__main__",
+                    "start": idx + 1,
+                    "end": idx + 1,
+                    "parent": "",
+                    "docstring": "",
+                }
+            )
+        while stack and indent < stack[-1][2]:
+            popped = stack.pop()
+            obj_ranges.append(
+                (popped[0], popped[1], popped[3], idx, popped[4], popped[2])
+            )
+    # Close any remaining open objects
+    for popped in stack:
+        obj_ranges.append(
+            (popped[0], popped[1], popped[3], len(lines), popped[4], popped[2])
+        )
+
+    # Now, extract docstrings for classes, functions, and methods
+    for obj in obj_ranges:
+        obj_type, name, start, end, parent, indent = obj
+        # Determine if this is a method
+        if obj_type == "function" and parent:
+            outline_type = "method"
+        elif obj_type == "function":
+            outline_type = "function"
+        else:
+            outline_type = obj_type
+        docstring = extract_docstring(lines, start, end)
+        outline.append(
+            {
+                "type": outline_type,
+                "name": name,
+                "start": start,
+                "end": end,
+                "parent": parent,
+                "docstring": docstring,
+            }
+        )
+    return outline
+
+
+def extract_docstring(lines, start_idx, end_idx):
+    """Extracts a docstring from lines[start_idx:end_idx] if present."""
+    for i in range(start_idx, min(end_idx, len(lines))):
+        line = lines[i].lstrip()
+        if not line:
+            continue
+        if line.startswith('"""') or line.startswith("'''"):
+            quote = line[:3]
+            doc = line[3:]
+            if doc.strip().endswith(quote):
+                return doc.strip()[:-3].strip()
+            docstring_lines = [doc]
+            for j in range(i + 1, min(end_idx, len(lines))):
+                line = lines[j]
+                if line.strip().endswith(quote):
+                    docstring_lines.append(line.strip()[:-3])
+                    return "\n".join([d.strip() for d in docstring_lines]).strip()
+                docstring_lines.append(line)
+            break
+        else:
+            break
+    return ""

janito/agent/tools/{search_outline.py → get_file_outline/search_outline.py}

@@ -1,4 +1,5 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 
 
@@ -9,6 +10,16 @@ class SearchOutlineTool(ToolBase):
     """
 
     def run(self, file_path: str) -> str:
+        from janito.agent.tools_utils.utils import display_path
+        from janito.i18n import tr
+
+        self.report_info(
+            ActionType.READ,
+            tr(
+                "🔍 Searching for outline in '{disp_path}'",
+                disp_path=display_path(file_path),
+            ),
+        )
         # ... rest of implementation ...
         # Example warnings and successes:
         # self.report_warning(tr("No files found with supported extensions."))