agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_toolsets/fsspec_toolset/grep.py

@@ -85,6 +85,66 @@ async def detect_grep_backend(env: ExecutionEnvironment) -> GrepBackend:
     return GrepBackend.PYTHON
 
 
+def _is_path_inside_ignored_dir(path: str) -> bool:
+    """Check if path is explicitly inside a commonly ignored directory.
+
+    Args:
+        path: The search path
+
+    Returns:
+        True if path is inside a directory that would typically be gitignored
+    """
+    # Common ignored directory patterns (without trailing slash)
+    ignored_dirs = [
+        ".venv",
+        "venv",
+        ".env",
+        "env",
+        "node_modules",
+        ".git",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".tox",
+        ".nox",
+    ]
+    for ignored in ignored_dirs:
+        if (
+            path.startswith((f"{ignored}/", f"./{ignored}/"))
+            or f"/{ignored}/" in path
+            or path == ignored
+        ):
+            return True
+    return False
+
+
+def _filter_exclude_patterns(path: str, exclude_patterns: list[str]) -> list[str]:
+    """Filter out exclude patterns that the search path is explicitly inside.
+
+    If user explicitly searches inside an excluded directory (e.g., .venv/),
+    don't exclude that directory from results.
+
+    Args:
+        path: The search path
+        exclude_patterns: List of patterns to potentially exclude
+
+    Returns:
+        Filtered list of exclude patterns
+    """
+    filtered = []
+    for pattern in exclude_patterns:
+        # Normalize pattern (remove trailing slash for comparison)
+        pattern_normalized = pattern.rstrip("/")
+        # Check if the search path starts with or contains this excluded dir
+        # e.g., path=".venv/lib/python" should not exclude ".venv/"
+        if not (
+            path.startswith((pattern_normalized, f"./{pattern_normalized}"))
+            or f"/{pattern_normalized}/" in path
+        ):
+            filtered.append(pattern)
+    return filtered
+
+
 async def grep_with_subprocess(
     env: ExecutionEnvironment,
     pattern: str,
@@ -124,11 +184,23 @@ async def grep_with_subprocess(
         msg = "Subprocess grep requested but no grep/ripgrep found"
         raise ValueError(msg)
 
-    exclude = exclude_patterns or DEFAULT_EXCLUDE_PATTERNS
+    base_exclude = exclude_patterns or DEFAULT_EXCLUDE_PATTERNS
+    # Filter out patterns that the user is explicitly searching inside
+    exclude = _filter_exclude_patterns(path, base_exclude)
+
+    # Disable gitignore if explicitly searching inside an ignored directory
+    # (e.g., searching .venv/ when .venv is in .gitignore)
+    effective_use_gitignore = use_gitignore and not _is_path_inside_ignored_dir(path)
 
     if backend == GrepBackend.RIPGREP:
         cmd_list = _build_ripgrep_command(
-            pattern, path, case_sensitive, max_matches, exclude, use_gitignore, context_lines
+            pattern,
+            path,
+            case_sensitive,
+            max_matches,
+            exclude,
+            effective_use_gitignore,
+            context_lines,
         )
     else:
         cmd_list = _build_gnu_grep_command(
@@ -256,19 +328,27 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
     matches: list[dict[str, Any]] = []
     total_bytes = 0
     was_truncated = False
+    match_count = 0  # Track actual matches (not context lines)
 
     for line in stdout.splitlines():
         if not line.strip():
             continue
         try:
             data = anyenv.load_json(line, return_type=dict)
-            if data.get("type") == "match":
+            entry_type = data.get("type")
+
+            if entry_type in ("match", "context"):
                 match_data = data.get("data", {})
                 path = match_data.get("path", {}).get("text", "")
                 line_num = match_data.get("line_number", 0)
                 content = match_data.get("lines", {}).get("text", "").rstrip("\n")
 
-                match_entry = {"path": path, "line": line_num, "content": content}
+                match_entry = {
+                    "path": path,
+                    "line": line_num,
+                    "content": content,
+                    "is_match": entry_type == "match",
+                }
                 entry_size = len(path) + len(str(line_num)) + len(content) + 10
 
                 if total_bytes + entry_size > max_output_bytes:
@@ -277,6 +357,9 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
 
                 matches.append(match_entry)
                 total_bytes += entry_size
+
+                if entry_type == "match":
+                    match_count += 1
         except anyenv.JsonLoadError:
             continue
 
@@ -291,11 +374,13 @@ def _parse_ripgrep_json_output(stdout: str, max_output_bytes: int) -> dict[str,
         # Truncate long lines for readability
         if len(content) > 100:  # noqa: PLR2004
             content = content[:97] + "..."
-        table_lines.append(f"| {m['path']} | {m['line']} | {content} |")
+        # Mark match lines with indicator if there are context lines
+        prefix = "→ " if m.get("is_match") and match_count < len(matches) else ""
+        table_lines.append(f"| {m['path']} | {m['line']} | {prefix}{content} |")
 
     return {
         "matches": "\n".join(table_lines),
-        "match_count": len(matches),
+        "match_count": match_count,
         "was_truncated": was_truncated,
     }
 
@@ -334,10 +419,17 @@ def _parse_gnu_grep_output(stdout: str, max_output_bytes: int) -> dict[str, Any]
 
     table_lines = ["| File | Line | Content |", "|------|------|---------|"]
     for m in matches:
+        # Handle separator lines
+        if m.get("is_separator"):
+            table_lines.append("| | | |")
+            continue
+
         content = m["content"].replace("|", "\\|")
         if len(content) > 100:  # noqa: PLR2004
             content = content[:97] + "..."
-        table_lines.append(f"| {m['path']} | {m['line']} | {content} |")
+        # Mark match lines with indicator if there are context lines
+        prefix = "→ " if m.get("is_match") else ""
+        table_lines.append(f"| {m['path']} | {m['line']} | {prefix}{content} |")
 
     return {
         "matches": "\n".join(table_lines),

agentpool_toolsets/fsspec_toolset/helpers.py

@@ -550,8 +550,9 @@ def truncate_lines(
     Returns:
         Tuple of (truncated_lines, was_truncated)
     """
-    # Apply offset
-    start_idx = max(0, offset)
+    # Apply offset (supports negative indexing like Python lists)
+    start_idx = max(0, len(lines) + offset) if offset < 0 else min(offset, len(lines))
+
     if start_idx >= len(lines):
         return [], False
 

agentpool_toolsets/fsspec_toolset/image_utils.py

@@ -0,0 +1,161 @@
+"""Image processing utilities for the fsspec toolset."""
+
+from __future__ import annotations
+
+from io import BytesIO
+
+
+# 4.5MB - provides headroom below Anthropic's 5MB limit
+DEFAULT_MAX_BYTES = int(4.5 * 1024 * 1024)
+
+# Minimum dimension for resized images
+MIN_DIMENSION = 100
+
+
+def _pick_smaller(
+    a: tuple[bytes, str],
+    b: tuple[bytes, str],
+) -> tuple[bytes, str]:
+    """Pick the smaller of two image buffers."""
+    return a if len(a[0]) <= len(b[0]) else b
+
+
+def _make_resize_note(
+    original_width: int,
+    original_height: int,
+    final_width: int,
+    final_height: int,
+    suffix: str = "",
+) -> str:
+    """Create a resize note string."""
+    scale = original_width / final_width if final_width > 0 else 1.0
+    base = f"[Image resized: {original_width}x{original_height} → {final_width}x{final_height}"
+    return f"{base}, scale={scale:.2f}x{suffix}]"
+
+
+def resize_image_if_needed(
+    data: bytes,
+    media_type: str,
+    max_size: int,
+    max_bytes: int | None = None,
+    jpeg_quality: int = 80,
+) -> tuple[bytes, str, str | None]:
+    """Resize image if it exceeds limits, preserving aspect ratio.
+
+    Returns the original image if it already fits within all limits.
+
+    Strategy for staying under max_bytes:
+    1. First resize to max_size dimensions
+    2. Try both PNG and JPEG formats, pick the smaller one
+    3. If still too large, try JPEG with decreasing quality
+    4. If still too large, progressively reduce dimensions
+
+    Args:
+        data: Raw image bytes
+        media_type: MIME type of the image
+        max_size: Maximum width/height in pixels
+        max_bytes: Maximum file size in bytes (default: 4.5MB)
+        jpeg_quality: Initial quality for JPEG output (1-100)
+
+    Returns:
+        Tuple of (image_data, media_type, dimension_note).
+        dimension_note is None if no resizing was needed, otherwise contains
+        a message about the resize for the model to map coordinates.
+    """
+    from PIL import Image
+
+    max_bytes = max_bytes if max_bytes is not None else DEFAULT_MAX_BYTES
+
+    img = Image.open(BytesIO(data))
+    original_width, original_height = img.size
+
+    # Check if already within all limits (dimensions AND size)
+    original_size = len(data)
+    if original_width <= max_size and original_height <= max_size and original_size <= max_bytes:
+        return data, media_type, None
+
+    # Calculate initial dimensions respecting max limits
+    target_width = original_width
+    target_height = original_height
+
+    if target_width > max_size:
+        target_height = round(target_height * max_size / target_width)
+        target_width = max_size
+    if target_height > max_size:
+        target_width = round(target_width * max_size / target_height)
+        target_height = max_size
+
+    def try_both_formats(
+        img: Image.Image,
+        width: int,
+        height: int,
+        quality: int,
+    ) -> tuple[bytes, str]:
+        """Resize and encode in both formats, returning the smaller one."""
+        resized = img.resize((width, height), Image.Resampling.LANCZOS)
+
+        # Convert to RGB for JPEG if needed (handles RGBA, P mode, etc.)
+        if resized.mode in ("RGBA", "LA", "P"):
+            rgb_img = Image.new("RGB", resized.size, (255, 255, 255))
+            if resized.mode == "P":
+                resized = resized.convert("RGBA")
+            rgb_img.paste(resized, mask=resized.split()[-1] if resized.mode == "RGBA" else None)
+            jpeg_source = rgb_img
+        else:
+            jpeg_source = resized.convert("RGB") if resized.mode != "RGB" else resized
+
+        # Try PNG
+        png_buf = BytesIO()
+        resized.save(png_buf, format="PNG", optimize=True)
+        png_data = png_buf.getvalue()
+
+        # Try JPEG
+        jpeg_buf = BytesIO()
+        jpeg_source.save(jpeg_buf, format="JPEG", quality=quality, optimize=True)
+        jpeg_data = jpeg_buf.getvalue()
+
+        return _pick_smaller((png_data, "image/png"), (jpeg_data, "image/jpeg"))
+
+    # Quality and scale steps for progressive reduction
+    quality_steps = [85, 70, 55, 40]
+    scale_steps = [1.0, 0.75, 0.5, 0.35, 0.25]
+
+    final_width = target_width
+    final_height = target_height
+
+    # First attempt: resize to target dimensions, try both formats
+    best_data, best_type = try_both_formats(img, target_width, target_height, jpeg_quality)
+
+    if len(best_data) <= max_bytes:
+        note = _make_resize_note(original_width, original_height, final_width, final_height)
+        return best_data, best_type, note
+
+    # Still too large - try with decreasing quality
+    for quality in quality_steps:
+        best_data, best_type = try_both_formats(img, target_width, target_height, quality)
+
+        if len(best_data) <= max_bytes:
+            note = _make_resize_note(original_width, original_height, final_width, final_height)
+            return best_data, best_type, note
+
+    # Still too large - reduce dimensions progressively
+    for scale_factor in scale_steps:
+        final_width = round(target_width * scale_factor)
+        final_height = round(target_height * scale_factor)
+
+        # Skip if dimensions are too small
+        if final_width < MIN_DIMENSION or final_height < MIN_DIMENSION:
+            break
+
+        for quality in quality_steps:
+            best_data, best_type = try_both_formats(img, final_width, final_height, quality)
+
+            if len(best_data) <= max_bytes:
+                note = _make_resize_note(original_width, original_height, final_width, final_height)
+                return best_data, best_type, note
+
+    # Last resort: return smallest version we produced even if over limit
+    note = _make_resize_note(
+        original_width, original_height, final_width, final_height, " (may exceed size limit)"
+    )
+    return best_data, best_type, note