minion-code 0.1.0__py3-none-any.whl

minion_code/tools/bash_tool.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Bash command execution tool
+"""
+
+import os
+import subprocess
+from typing import Optional
+from minion.tools import BaseTool
+
+
+class BashTool(BaseTool):
+    """Bash command execution tool"""
+
+    name = "bash"
+    description = "Execute bash commands"
+    readonly = False  # Command execution may modify system state
+    inputs = {
+        "command": {"type": "string", "description": "Bash command to execute"},
+        "timeout": {
+            "type": "integer",
+            "description": "Timeout in seconds",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def forward(self, command: str, timeout: Optional[int] = 30) -> str:
+        """Execute bash command"""
+        try:
+            # Security check: prohibit dangerous commands
+            dangerous_commands = ["rm -rf", "sudo", "su", "chmod 777", "mkfs", "dd if="]
+            if any(dangerous in command.lower() for dangerous in dangerous_commands):
+                return f"Error: Dangerous command prohibited - {command}"
+
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=os.getcwd(),
+            )
+
+            output = ""
+            if result.stdout:
+                output += f"Standard output:\n{result.stdout}\n"
+            if result.stderr:
+                output += f"Standard error:\n{result.stderr}\n"
+            output += f"Exit code: {result.returncode}"
+
+            return output
+
+        except subprocess.TimeoutExpired:
+            return f"Command execution timeout ({timeout} seconds)"
+        except Exception as e:
+            return f"Error executing command: {str(e)}"

minion_code/tools/file_edit_tool.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""
+File editing tool based on TypeScript FileEditTool implementation.
+"""
+
+import os
+import time
+from pathlib import Path
+from typing import Dict, Any, Optional
+from minion.tools import BaseTool
+from minion_code.services import record_file_read, record_file_edit, check_file_freshness
+
+
+class FileEditTool(BaseTool):
+    """
+    A tool for editing files with string replacement.
+    Based on the TypeScript FileEditTool implementation.
+    """
+    
+    name = "file_edit"
+    description = "A tool for editing files by replacing old_string with new_string with freshness tracking"
+    readonly = False
+    
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "The absolute path to the file to modify"
+        },
+        "old_string": {
+            "type": "string", 
+            "description": "The text to replace (must be unique within the file)"
+        },
+        "new_string": {
+            "type": "string",
+            "description": "The text to replace it with"
+        }
+    }
+    output_type = "string"
+    
+    def forward(self, file_path: str, old_string: str, new_string: str) -> str:
+        """Execute file edit operation."""
+        try:
+            # Validate inputs
+            validation_result = self._validate_input(file_path, old_string, new_string)
+            if not validation_result["valid"]:
+                return f"Error: {validation_result['message']}"
+            
+            # Apply the edit
+            result = self._apply_edit(file_path, old_string, new_string)
+            return result
+            
+        except Exception as e:
+            return f"Error during file edit: {str(e)}"
+    
+    def _validate_input(self, file_path: str, old_string: str, new_string: str) -> Dict[str, Any]:
+        """Validate input parameters."""
+        
+        # Check if old_string and new_string are the same
+        if old_string == new_string:
+            return {
+                "valid": False,
+                "message": "No changes to make: old_string and new_string are exactly the same."
+            }
+        
+        # Resolve absolute path
+        if not os.path.isabs(file_path):
+            file_path = os.path.abspath(file_path)
+        
+        # Handle new file creation
+        if not os.path.exists(file_path) and old_string == "":
+            return {"valid": True}
+        
+        # Check if file exists for existing file edits
+        if not os.path.exists(file_path):
+            return {
+                "valid": False,
+                "message": "File does not exist."
+            }
+        
+        # Check if it's a Jupyter notebook
+        if file_path.endswith('.ipynb'):
+            return {
+                "valid": False,
+                "message": "File is a Jupyter Notebook. Use NotebookEdit tool instead."
+            }
+        
+        # Check file freshness (if we have tracking)
+        try:
+            freshness_result = check_file_freshness(file_path)
+            if freshness_result.conflict:
+                return {
+                    "valid": False,
+                    "message": "File has been modified since last read. Read it again before editing."
+                }
+        except Exception:
+            # If freshness checking fails, continue with basic validation
+            pass
+        
+        # Check if file is binary
+        if self._is_binary_file(file_path):
+            return {
+                "valid": False,
+                "message": "Cannot edit binary files."
+            }
+        
+        # For existing files, validate old_string exists and is unique
+        if old_string != "":
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                if old_string not in content:
+                    return {
+                        "valid": False,
+                        "message": "String to replace not found in file."
+                    }
+                
+                # Check for multiple matches
+                matches = content.count(old_string)
+                if matches > 1:
+                    return {
+                        "valid": False,
+                        "message": f"Found {matches} matches of the string to replace. "
+                                 "For safety, this tool only supports replacing exactly one occurrence at a time. "
+                                 "Add more lines of context to your edit and try again."
+                    }
+                
+            except UnicodeDecodeError:
+                return {
+                    "valid": False,
+                    "message": "Cannot read file - appears to be binary or has encoding issues."
+                }
+        
+        return {"valid": True}
+    
+    def _apply_edit(self, file_path: str, old_string: str, new_string: str) -> str:
+        """Apply the edit to the file."""
+        
+        # Resolve absolute path
+        if not os.path.isabs(file_path):
+            file_path = os.path.abspath(file_path)
+        
+        # Handle new file creation
+        if old_string == "":
+            # Create new file
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(new_string)
+            
+            # Record the file edit
+            record_file_edit(file_path, new_string)
+            
+            return f"Successfully created new file: {file_path}"
+        
+        # Edit existing file
+        try:
+            # Read current content
+            with open(file_path, 'r', encoding='utf-8') as f:
+                original_content = f.read()
+            
+            # Apply replacement
+            if new_string == "":
+                # Handle deletion - check if we need to remove trailing newline
+                if (not old_string.endswith('\n') and 
+                    original_content.find(old_string + '\n') != -1):
+                    updated_content = original_content.replace(old_string + '\n', new_string)
+                else:
+                    updated_content = original_content.replace(old_string, new_string)
+            else:
+                updated_content = original_content.replace(old_string, new_string)
+            
+            # Verify the replacement worked
+            if updated_content == original_content:
+                return "Error: Original and edited file match exactly. Failed to apply edit."
+            
+            # Write updated content
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(updated_content)
+            
+            # Record the file edit
+            record_file_edit(file_path, updated_content)
+            
+            # Generate result message with snippet
+            snippet_info = self._get_snippet(original_content, old_string, new_string)
+            
+            result = f"The file {file_path} has been updated. Here's the result of the edit:\n"
+            result += self._add_line_numbers(snippet_info['snippet'], snippet_info['start_line'])
+            
+            return result
+            
+        except Exception as e:
+            return f"Error applying edit: {str(e)}"
+    
+    def _is_binary_file(self, file_path: str) -> bool:
+        """Check if file is binary."""
+        try:
+            with open(file_path, 'rb') as f:
+                chunk = f.read(1024)
+                return b'\0' in chunk
+        except Exception:
+            return False
+    
+    def _get_snippet(self, original_content: str, old_string: str, new_string: str, 
+                    context_lines: int = 4) -> Dict[str, Any]:
+        """Get a snippet of the file showing the change with context."""
+        
+        # Find the replacement position
+        before_replacement = original_content.split(old_string)[0]
+        replacement_line = before_replacement.count('\n')
+        
+        # Create the new content
+        new_content = original_content.replace(old_string, new_string)
+        new_lines = new_content.split('\n')
+        
+        # Calculate snippet boundaries
+        start_line = max(0, replacement_line - context_lines)
+        end_line = min(len(new_lines), replacement_line + context_lines + new_string.count('\n') + 1)
+        
+        # Extract snippet
+        snippet_lines = new_lines[start_line:end_line]
+        snippet = '\n'.join(snippet_lines)
+        
+        return {
+            'snippet': snippet,
+            'start_line': start_line + 1  # Convert to 1-based line numbers
+        }
+    
+    def _add_line_numbers(self, content: str, start_line: int = 1) -> str:
+        """Add line numbers to content."""
+        lines = content.split('\n')
+        numbered_lines = []
+        
+        for i, line in enumerate(lines):
+            line_num = start_line + i
+            numbered_lines.append(f"{line_num:6d}  {line}")
+        
+        return '\n'.join(numbered_lines)

minion_code/tools/file_read_tool.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+File reading tool
+"""
+
+from pathlib import Path
+from typing import Optional
+from minion.tools import BaseTool
+
+
+class FileReadTool(BaseTool):
+    """File reading tool"""
+
+    name = "file_read"
+    description = "Read file content, supports text files and image files"
+    readonly = True  # Read-only tool, does not modify system state
+    inputs = {
+        "file_path": {"type": "string", "description": "File path to read"},
+        "offset": {
+            "type": "integer",
+            "description": "Starting line number (optional)",
+            "nullable": True,
+        },
+        "limit": {
+            "type": "integer",
+            "description": "Line count limit (optional)",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def forward(
+        self, file_path: str, offset: Optional[int] = None, limit: Optional[int] = None
+    ) -> str:
+        """Read file content"""
+        try:
+            path = Path(file_path)
+            if not path.exists():
+                return f"Error: File does not exist - {file_path}"
+
+            if not path.is_file():
+                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"}
+            if path.suffix.lower() in image_extensions:
+                return f"Image file: {file_path} (size: {path.stat().st_size} bytes)"
+
+            # Read text file
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+
+            total_lines = len(lines)
+
+            # Apply offset and limit
+            if offset is not None:
+                lines = lines[offset:]
+            if limit is not None:
+                lines = lines[:limit]
+
+            content = "".join(lines)
+
+            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}"
+
+            return result
+
+        except Exception as e:
+            return f"Error reading file: {str(e)}"

minion_code/tools/file_write_tool.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+File writing tool
+"""
+
+from pathlib import Path
+from minion.tools import BaseTool
+
+
+class FileWriteTool(BaseTool):
+    """File writing tool"""
+
+    name = "file_write"
+    description = "Write content to file"
+    readonly = False  # Writing tool, modifies system state
+    inputs = {
+        "file_path": {"type": "string", "description": "File path to write to"},
+        "content": {"type": "string", "description": "Content to write"},
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str, content: str) -> str:
+        """Write file content"""
+        try:
+            path = 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:
+                f.write(content)
+
+            return f"Successfully wrote to file: {file_path} ({len(content)} characters)"
+
+        except Exception as e:
+            return f"Error writing file: {str(e)}"

minion_code/tools/glob_tool.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+File pattern matching tool
+"""
+
+import glob
+from pathlib import Path
+from minion.tools import BaseTool
+
+
+class GlobTool(BaseTool):
+    """File pattern matching tool"""
+
+    name = "glob"
+    description = "Match files using glob patterns"
+    readonly = True  # Read-only tool, does not modify system state
+    inputs = {
+        "pattern": {"type": "string", "description": "Glob pattern"},
+        "path": {"type": "string", "description": "Search path", "nullable": True},
+    }
+    output_type = "string"
+
+    def forward(self, pattern: str, path: str = ".") -> str:
+        """Match files using glob pattern"""
+        try:
+            search_path = Path(path)
+            if not search_path.exists():
+                return f"Error: Path does not exist - {path}"
+
+            # Build complete search pattern
+            if search_path.is_dir():
+                full_pattern = str(search_path / pattern)
+            else:
+                full_pattern = pattern
+
+            matches = glob.glob(full_pattern, recursive=True)
+            matches.sort()
+
+            if not matches:
+                return f"No files found matching pattern '{pattern}'"
+
+            result = f"Files matching pattern '{pattern}':\n"
+            for match in matches:
+                path_obj = Path(match)
+                if path_obj.is_file():
+                    size = path_obj.stat().st_size
+                    result += f"  File: {match} ({size} bytes)\n"
+                elif path_obj.is_dir():
+                    result += f"  Directory: {match}/\n"
+                else:
+                    result += f"  Other: {match}\n"
+
+            result += f"\nTotal {len(matches)} matches found"
+            return result
+
+        except Exception as e:
+            return f"Error during glob matching: {str(e)}"

minion_code/tools/grep_tool.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Text search tool
+"""
+
+import re
+from pathlib import Path
+from typing import List, Optional
+from minion.tools import BaseTool
+
+
+class GrepTool(BaseTool):
+    """Text search tool"""
+
+    name = "grep"
+    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"},
+        "path": {"type": "string", "description": "Search path (file or directory)"},
+        "include": {
+            "type": "string",
+            "description": "File pattern to include (optional)",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def forward(
+        self, pattern: str, path: str = ".", include: Optional[str] = None
+    ) -> str:
+        """Search for text pattern"""
+        try:
+            search_path = Path(path)
+            if not search_path.exists():
+                return f"Error: Path does not exist - {path}"
+
+            matches = []
+
+            if search_path.is_file():
+                # Search single file
+                matches.extend(self._search_file(search_path, pattern))
+            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))
+                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))
+
+            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"
+
+            result += f"\nTotal {len(matches)} matches found"
+            return 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"""
+        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):
+                        matches.append((str(file_path), line_num, line))
+        except Exception:
+            # Ignore files that cannot be read
+            pass
+        return matches
+
+    def _is_text_file(self, file_path: Path) -> bool:
+        """Check if file is a text file"""
+        text_extensions = {
+            ".txt",
+            ".py",
+            ".js",
+            ".html",
+            ".css",
+            ".json",
+            ".xml",
+            ".md",
+            ".yml",
+            ".yaml",
+            ".ini",
+            ".cfg",
+            ".conf",
+        }
+        return file_path.suffix.lower() in text_extensions

minion_code/tools/ls_tool.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Directory listing tool
+"""
+
+from pathlib import Path
+from minion.tools import BaseTool
+
+
+class LsTool(BaseTool):
+    """Directory listing tool"""
+
+    name = "ls"
+    description = "List directory contents"
+    readonly = True  # Read-only tool, does not modify system state
+    inputs = {
+        "path": {"type": "string", "description": "Directory path to list", "nullable": True},
+        "recursive": {
+            "type": "boolean",
+            "description": "Whether to list recursively",
+            "nullable": True,
+        },
+    }
+    output_type = "string"
+
+    def forward(self, path: str = ".", recursive: bool = False) -> str:
+        """List directory contents"""
+        try:
+            dir_path = Path(path)
+            if not dir_path.exists():
+                return f"Error: Path does not exist - {path}"
+
+            if not dir_path.is_dir():
+                return f"Error: Path is not a directory - {path}"
+
+            result = f"Directory contents: {path}\n\n"
+
+            if recursive:
+                # List recursively
+                for item in sorted(dir_path.rglob("*")):
+                    relative_path = item.relative_to(dir_path)
+                    if item.is_file():
+                        size = item.stat().st_size
+                        result += f"  File: {relative_path} ({size} bytes)\n"
+                    elif item.is_dir():
+                        result += f"  Directory: {relative_path}/\n"
+            else:
+                # List current directory only
+                items = list(dir_path.iterdir())
+                items.sort(key=lambda x: (x.is_file(), x.name.lower()))
+
+                for item in items:
+                    if item.is_file():
+                        size = item.stat().st_size
+                        result += f"  File: {item.name} ({size} bytes)\n"
+                    elif item.is_dir():
+                        result += f"  Directory: {item.name}/\n"
+                    else:
+                        result += f"  Other: {item.name}\n"
+
+            return result
+
+        except Exception as e:
+            return f"Error listing directory: {str(e)}"