minion-code 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

minion_code/tools/file_read_tool.py

@@ -4,13 +4,26 @@
 File reading tool
 """
 
+import base64
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union, Any
 from minion.tools import BaseTool
+from ..utils.output_truncator import (
+    check_file_size_before_read,
+    FileTooLargeError,
+    truncate_output,
+)
+
+try:
+    from PIL import Image
+
+    HAS_PIL = True
+except ImportError:
+    HAS_PIL = False
 
 
 class FileReadTool(BaseTool):
-    """File reading tool"""
+    """File reading tool with image support"""
 
     name = "file_read"
     description = "Read file content, supports text files and image files"
@@ -19,23 +32,46 @@ class FileReadTool(BaseTool):
         "file_path": {"type": "string", "description": "File path to read"},
         "offset": {
             "type": "integer",
-            "description": "Starting line number (optional)",
+            "description": "Starting line number (optional, for text files)",
             "nullable": True,
         },
         "limit": {
             "type": "integer",
-            "description": "Line count limit (optional)",
+            "description": "Line count limit (optional, for text files)",
             "nullable": True,
         },
     }
-    output_type = "string"
+    output_type = "any"  # Can return string or PIL.Image
+
+    def __init__(self, workdir: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir) if workdir else None
+        # State tracking for last execution
+        self._last_file_path = None
+        self._last_offset = None
+        self._last_limit = None
+        self._last_total_lines = None
+
+    def _resolve_path(self, file_path: str) -> Path:
+        """Resolve path using workdir if path is relative."""
+        path = Path(file_path)
+        if path.is_absolute():
+            return path
+        if self.workdir:
+            return self.workdir / path
+        return path  # Relative to cwd (backward compatible)
 
     def forward(
         self, file_path: str, offset: Optional[int] = None, limit: Optional[int] = None
-    ) -> str:
-        """Read file content"""
+    ) -> Union[str, Any]:
+        """Read file content
+
+        Returns:
+            - For text files: returns the text content as string
+            - For image files: returns PIL.Image object (or error string if PIL not available)
+        """
         try:
-            path = Path(file_path)
+            path = self._resolve_path(file_path)
             if not path.exists():
                 return f"Error: File does not exist - {file_path}"
 
@@ -43,31 +79,152 @@ class FileReadTool(BaseTool):
                 return f"Error: Path is not a file - {file_path}"
 
             # Check if it's an image file
-            image_extensions = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"}
+            image_extensions = {
+                ".png",
+                ".jpg",
+                ".jpeg",
+                ".gif",
+                ".bmp",
+                ".webp",
+                ".tiff",
+                ".svg",
+            }
             if path.suffix.lower() in image_extensions:
-                return f"Image file: {file_path} (size: {path.stat().st_size} bytes)"
+                return self._read_image(path)
+
+            # 执行前检查文件大小（仅对非分页读取）
+            if offset is None and limit is None:
+                try:
+                    check_file_size_before_read(file_path)
+                except FileTooLargeError as e:
+                    return f"Error: {str(e)}"
 
             # Read text file
-            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                lines = f.readlines()
+            return self._read_text(path, offset, limit)
+
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
 
-            total_lines = len(lines)
+    def _read_image(self, path: Path) -> Union[Any, str]:
+        """Read image file and return PIL.Image object"""
+        if not HAS_PIL:
+            return (
+                f"Error: PIL (Pillow) is not installed. Cannot read image file: {path}"
+            )
 
-            # Apply offset and limit
-            if offset is not None:
-                lines = lines[offset:]
-            if limit is not None:
-                lines = lines[:limit]
+        try:
+            image = Image.open(path)
+            # Store state for format_for_observation
+            self._last_file_path = str(path)
+            self._last_offset = None
+            self._last_limit = None
+            self._last_total_lines = None
+            return image
+        except Exception as e:
+            return f"Error opening image file {path}: {str(e)}"
 
-            content = "".join(lines)
+    def _read_text(
+        self, path: Path, offset: Optional[int] = None, limit: Optional[int] = None
+    ) -> str:
+        """Read text file and return content"""
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            lines = f.readlines()
 
-            result = f"File: {file_path}\n"
-            result += f"Total lines: {total_lines}\n"
-            if offset is not None or limit is not None:
-                result += f"Displayed lines: {len(lines)}\n"
-            result += f"Content:\n{content}"
+        total_lines = len(lines)
 
-            return result
+        # Store state for format_for_observation
+        self._last_file_path = str(path)
+        self._last_offset = offset
+        self._last_limit = limit
+        self._last_total_lines = total_lines
+
+        # Apply offset and limit
+        if offset is not None:
+            lines = lines[offset:]
+        if limit is not None:
+            lines = lines[:limit]
+
+        content = "".join(lines)
+        return content
+
+    def format_for_observation(self, output: Any) -> str:
+        """Format tool output for LLM observation.
+
+        For images: Convert PIL.Image to base64 encoded format
+        For text: Add line numbers and metadata
+        """
+        # Handle error strings
+        if isinstance(output, str) and output.startswith("Error:"):
+            return output
 
+        # Handle PIL Image
+        if HAS_PIL and isinstance(output, Image.Image):
+            return self._format_image_for_observation(output)
+
+        # Handle text content
+        if isinstance(output, str):
+            return self._format_text_for_observation(output)
+
+        # Fallback
+        return str(output) if output is not None else ""
+
+    def _format_image_for_observation(self, image: Any) -> str:
+        """Format PIL Image as base64 for LLM observation"""
+        import io
+
+        try:
+            # Convert image to RGB if necessary (for PNG with transparency, etc.)
+            if image.mode not in ("RGB", "L"):
+                image = image.convert("RGB")
+
+            # Save image to bytes buffer
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            buffer.seek(0)
+
+            # Encode as base64
+            img_base64 = base64.b64encode(buffer.read()).decode("utf-8")
+
+            # Format for LLM observation
+            result = f"Image file: {self._last_file_path}\n"
+            result += f"Size: {image.size[0]}x{image.size[1]} pixels\n"
+            result += f"Mode: {image.mode}\n"
+            result += f"Format: {image.format}\n"
+            result += f"\nBase64 encoded image:\n"
+            result += f"data:image/png;base64,{img_base64}"
+
+            return result
         except Exception as e:
-            return f"Error reading file: {str(e)}"
+            return f"Error formatting image for observation: {str(e)}"
+
+    def _format_text_for_observation(self, content: str) -> str:
+        """Format text content with line numbers for LLM observation"""
+        if not content:
+            return f"File: {self._last_file_path}\n(empty file)"
+
+        lines = content.splitlines(keepends=True)
+
+        # Calculate starting line number
+        start_line = 1
+        if self._last_offset is not None:
+            start_line = self._last_offset + 1
+
+        # Add line numbers
+        numbered_lines = []
+        for i, line in enumerate(lines, start=start_line):
+            # Format: line_number→content
+            numbered_lines.append(f"{i:5d}→{line}")
+
+        result = f"File: {self._last_file_path}\n"
+        if self._last_total_lines is not None:
+            result += f"Total lines: {self._last_total_lines}\n"
+        if self._last_offset is not None or self._last_limit is not None:
+            result += f"Displayed lines: {len(lines)}"
+            if self._last_offset is not None:
+                result += f" (starting from line {start_line})"
+            result += "\n"
+        result += "\n"
+        result += "".join(numbered_lines)
+
+        # 应用输出截断
+        return truncate_output(result, tool_name=self.name)

minion_code/tools/file_write_tool.py

@@ -5,6 +5,7 @@ File writing tool
 """
 
 from pathlib import Path
+from typing import Optional
 from minion.tools import BaseTool
 
 
@@ -20,17 +21,30 @@ class FileWriteTool(BaseTool):
     }
     output_type = "string"
 
+    def __init__(self, workdir: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir) if workdir else None
+
+    def _resolve_path(self, file_path: str) -> Path:
+        """Resolve path using workdir if path is relative."""
+        path = Path(file_path)
+        if path.is_absolute():
+            return path
+        if self.workdir:
+            return self.workdir / path
+        return path  # Relative to cwd (backward compatible)
+
     def forward(self, file_path: str, content: str) -> str:
         """Write file content"""
         try:
-            path = Path(file_path)
+            path = self._resolve_path(file_path)
             # Create directory if it doesn't exist
             path.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(file_path, "w", encoding="utf-8") as f:
+            with open(path, "w", encoding="utf-8") as f:
                 f.write(content)
 
-            return f"Successfully wrote to file: {file_path} ({len(content)} characters)"
+            return f"Successfully wrote to file: {path} ({len(content)} characters)"
 
         except Exception as e:
             return f"Error writing file: {str(e)}"

minion_code/tools/glob_tool.py

@@ -6,7 +6,9 @@ File pattern matching tool
 
 import glob
 from pathlib import Path
+from typing import Any, Optional
 from minion.tools import BaseTool
+from ..utils.output_truncator import truncate_output
 
 
 class GlobTool(BaseTool):
@@ -21,10 +23,23 @@ class GlobTool(BaseTool):
     }
     output_type = "string"
 
+    def __init__(self, workdir: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir) if workdir else None
+
+    def _resolve_path(self, path: str) -> Path:
+        """Resolve path using workdir if path is relative."""
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        if self.workdir:
+            return self.workdir / p
+        return p  # Relative to cwd (backward compatible)
+
     def forward(self, pattern: str, path: str = ".") -> str:
         """Match files using glob pattern"""
         try:
-            search_path = Path(path)
+            search_path = self._resolve_path(path)
             if not search_path.exists():
                 return f"Error: Path does not exist - {path}"
 
@@ -52,7 +67,13 @@ class GlobTool(BaseTool):
                     result += f"  Other: {match}\n"
 
             result += f"\nTotal {len(matches)} matches found"
-            return result
+            return self.format_for_observation(result)
 
         except Exception as e:
             return f"Error during glob matching: {str(e)}"
+
+    def format_for_observation(self, output: Any) -> str:
+        """格式化输出，自动截断过大内容"""
+        if isinstance(output, str):
+            return truncate_output(output, tool_name=self.name)
+        return str(output)

minion_code/tools/grep_tool.py

@@ -6,8 +6,9 @@ Text search tool
 
 import re
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Any
 from minion.tools import BaseTool
+from ..utils.output_truncator import truncate_output
 
 
 class GrepTool(BaseTool):
@@ -17,22 +18,84 @@ class GrepTool(BaseTool):
     description = "Search for text patterns in files"
     readonly = True  # Read-only tool, does not modify system state
     inputs = {
-        "pattern": {"type": "string", "description": "Regular expression pattern to search for"},
+        "pattern": {
+            "type": "string",
+            "description": "Regular expression pattern to search for",
+        },
         "path": {"type": "string", "description": "Search path (file or directory)"},
         "include": {
             "type": "string",
             "description": "File pattern to include (optional)",
             "nullable": True,
         },
+        "output_mode": {
+            "type": "string",
+            "description": "Output mode: 'content' (show matching lines), 'files_with_matches' (show file paths), 'count' (show match counts)",
+            "nullable": True,
+        },
+        "head_limit": {
+            "type": "integer",
+            "description": "Limit output to first N entries",
+            "nullable": True,
+        },
+        "after_context": {
+            "type": "integer",
+            "description": "Number of lines to show after each match (-A)",
+            "nullable": True,
+        },
+        "before_context": {
+            "type": "integer",
+            "description": "Number of lines to show before each match (-B)",
+            "nullable": True,
+        },
+        "context": {
+            "type": "integer",
+            "description": "Number of lines to show before and after each match (-C)",
+            "nullable": True,
+        },
     }
     output_type = "string"
 
+    def __init__(self, workdir: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir) if workdir else None
+
+    def _resolve_path(self, path: str) -> Path:
+        """Resolve path using workdir if path is relative."""
+        p = Path(path)
+        if p.is_absolute():
+            return p
+        if self.workdir:
+            return self.workdir / p
+        return p  # Relative to cwd (backward compatible)
+
     def forward(
-        self, pattern: str, path: str = ".", include: Optional[str] = None
+        self,
+        pattern: str,
+        path: str = ".",
+        include: Optional[str] = None,
+        output_mode: Optional[str] = None,
+        head_limit: Optional[int] = None,
+        after_context: Optional[int] = None,
+        before_context: Optional[int] = None,
+        context: Optional[int] = None,
     ) -> str:
         """Search for text pattern"""
         try:
-            search_path = Path(path)
+            # Default to 'content' mode for backward compatibility
+            if output_mode is None:
+                output_mode = "content"
+
+            # Validate output_mode
+            if output_mode not in ["content", "files_with_matches", "count"]:
+                return f"Error: Invalid output_mode '{output_mode}'. Must be 'content', 'files_with_matches', or 'count'"
+
+            # Handle context parameters (-C sets both -A and -B)
+            if context is not None:
+                after_context = context
+                before_context = context
+
+            search_path = self._resolve_path(path)
             if not search_path.exists():
                 return f"Error: Path does not exist - {path}"
 
@@ -40,45 +103,184 @@ class GrepTool(BaseTool):
 
             if search_path.is_file():
                 # Search single file
-                matches.extend(self._search_file(search_path, pattern))
+                matches.extend(
+                    self._search_file(
+                        search_path, pattern, before_context, after_context
+                    )
+                )
             else:
                 # Search directory
                 if include:
                     # Filter using file pattern
                     for file_path in search_path.rglob(include):
                         if file_path.is_file():
-                            matches.extend(self._search_file(file_path, pattern))
+                            matches.extend(
+                                self._search_file(
+                                    file_path, pattern, before_context, after_context
+                                )
+                            )
                 else:
                     # Search all text files
                     for file_path in search_path.rglob("*"):
                         if file_path.is_file() and self._is_text_file(file_path):
-                            matches.extend(self._search_file(file_path, pattern))
+                            matches.extend(
+                                self._search_file(
+                                    file_path, pattern, before_context, after_context
+                                )
+                            )
 
             if not matches:
                 return f"No content found matching pattern '{pattern}'"
 
-            # Group results by file
-            result = f"Search results for pattern '{pattern}':\n\n"
-            current_file = None
-            for file_path, line_num, line_content in matches:
-                if file_path != current_file:
-                    result += f"File: {file_path}\n"
-                    current_file = file_path
-                result += f"  Line {line_num}: {line_content.strip()}\n"
+            # Format output based on mode
+            if output_mode == "files_with_matches":
+                result = self._format_files_with_matches(matches, pattern, head_limit)
+            elif output_mode == "count":
+                result = self._format_count(matches, pattern, head_limit)
+            else:  # content mode
+                result = self._format_content(
+                    matches, pattern, head_limit, before_context, after_context
+                )
 
-            result += f"\nTotal {len(matches)} matches found"
-            return result
+            return self.format_for_observation(result)
 
         except Exception as e:
             return f"Error during search: {str(e)}"
 
-    def _search_file(self, file_path: Path, pattern: str) -> List[tuple]:
-        """Search pattern in a single file"""
+    def _format_content(
+        self,
+        matches: List[tuple],
+        pattern: str,
+        head_limit: Optional[int],
+        before_context: Optional[int] = None,
+        after_context: Optional[int] = None,
+    ) -> str:
+        """Format matches as content with line numbers and optional context"""
+        result = f"Search results for pattern '{pattern}':\n\n"
+        current_file = None
+        count = 0
+        has_context = before_context or after_context
+
+        for match in matches:
+            if head_limit and count >= head_limit:
+                result += f"\n(Output limited to {head_limit} matches)"
+                break
+
+            # Unpack match tuple based on whether it has context
+            if has_context and len(match) == 5:
+                file_path, line_num, line_content, before_lines, after_lines = match
+            else:
+                file_path, line_num, line_content = match[:3]
+                before_lines = []
+                after_lines = []
+
+            if file_path != current_file:
+                if current_file is not None and has_context:
+                    result += "--\n"  # Separator between files
+                result += f"File: {file_path}\n"
+                current_file = file_path
+
+            # Show before context lines
+            for ctx_line_num, ctx_line in before_lines:
+                result += f"  {ctx_line_num}-  {ctx_line.rstrip()}\n"
+
+            # Show the matching line (highlighted with :)
+            result += f"  {line_num}:  {line_content.rstrip()}\n"
+
+            # Show after context lines
+            for ctx_line_num, ctx_line in after_lines:
+                result += f"  {ctx_line_num}-  {ctx_line.rstrip()}\n"
+
+            # Add separator between matches if using context
+            if has_context:
+                result += "--\n"
+
+            count += 1
+
+        result += f"\nTotal {len(matches)} matches found"
+        return result
+
+    def _format_files_with_matches(
+        self, matches: List[tuple], pattern: str, head_limit: Optional[int]
+    ) -> str:
+        """Format matches as list of unique file paths"""
+        # Get unique file paths
+        unique_files = []
+        seen = set()
+        for file_path, _, _ in matches:
+            if file_path not in seen:
+                seen.add(file_path)
+                unique_files.append(file_path)
+                if head_limit and len(unique_files) >= head_limit:
+                    break
+
+        result = f"Files matching pattern '{pattern}':\n\n"
+        for file_path in unique_files:
+            result += f"{file_path}\n"
+
+        if head_limit and len(seen) > head_limit:
+            result += f"\n(Output limited to {head_limit} files)"
+        result += f"\nTotal {len(seen)} files with matches"
+        return result
+
+    def _format_count(
+        self, matches: List[tuple], pattern: str, head_limit: Optional[int]
+    ) -> str:
+        """Format matches as count per file"""
+        # Count matches per file
+        file_counts = {}
+        for file_path, _, _ in matches:
+            file_counts[file_path] = file_counts.get(file_path, 0) + 1
+
+        result = f"Match counts for pattern '{pattern}':\n\n"
+        count = 0
+        for file_path, match_count in file_counts.items():
+            if head_limit and count >= head_limit:
+                result += f"\n(Output limited to {head_limit} files)"
+                break
+            result += f"{file_path}: {match_count} matches\n"
+            count += 1
+
+        result += (
+            f"\nTotal {sum(file_counts.values())} matches in {len(file_counts)} files"
+        )
+        return result
+
+    def _search_file(
+        self,
+        file_path: Path,
+        pattern: str,
+        before_context: Optional[int] = None,
+        after_context: Optional[int] = None,
+    ) -> List[tuple]:
+        """Search pattern in a single file with optional context lines"""
         matches = []
         try:
             with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-                for line_num, line in enumerate(f, 1):
-                    if re.search(pattern, line, re.IGNORECASE):
+                lines = f.readlines()
+
+            total_lines = len(lines)
+            for line_num, line in enumerate(lines, 1):
+                if re.search(pattern, line, re.IGNORECASE):
+                    if before_context or after_context:
+                        # Collect before context
+                        before_lines = []
+                        if before_context:
+                            start = max(0, line_num - 1 - before_context)
+                            for i in range(start, line_num - 1):
+                                before_lines.append((i + 1, lines[i]))
+
+                        # Collect after context
+                        after_lines = []
+                        if after_context:
+                            end = min(total_lines, line_num + after_context)
+                            for i in range(line_num, end):
+                                after_lines.append((i + 1, lines[i]))
+
+                        matches.append(
+                            (str(file_path), line_num, line, before_lines, after_lines)
+                        )
+                    else:
                         matches.append((str(file_path), line_num, line))
         except Exception:
             # Ignore files that cannot be read
@@ -103,3 +305,9 @@ class GrepTool(BaseTool):
             ".conf",
         }
         return file_path.suffix.lower() in text_extensions
+
+    def format_for_observation(self, output: Any) -> str:
+        """格式化输出，自动截断过大内容"""
+        if isinstance(output, str):
+            return truncate_output(output, tool_name=self.name)
+        return str(output)