feat: personal ai agent framework

agent/tools/find/__init__.py

@@ -0,0 +1,3 @@
+from .find import Find
+
+__all__ = ['Find']

agent/tools/find/find.py

@@ -0,0 +1,177 @@
+"""
+Find tool - Search for files by glob pattern
+"""
+
+import os
+import glob as glob_module
+from typing import Dict, Any, List
+
+from agent.tools.base_tool import BaseTool, ToolResult
+from agent.tools.utils.truncate import truncate_head, format_size, DEFAULT_MAX_BYTES
+
+
+DEFAULT_LIMIT = 1000
+
+
+class Find(BaseTool):
+    """Tool for finding files by pattern"""
+    
+    name: str = "find"
+    description: str = f"Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to {DEFAULT_LIMIT} results or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first)."
+    
+    params: dict = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "description": "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"
+            },
+            "path": {
+                "type": "string",
+                "description": "Directory to search in (default: current directory)"
+            },
+            "limit": {
+                "type": "integer",
+                "description": f"Maximum number of results (default: {DEFAULT_LIMIT})"
+            }
+        },
+        "required": ["pattern"]
+    }
+    
+    def __init__(self, config: dict = None):
+        self.config = config or {}
+        self.cwd = self.config.get("cwd", os.getcwd())
+    
+    def execute(self, args: Dict[str, Any]) -> ToolResult:
+        """
+        Execute file search
+        
+        :param args: Search parameters
+        :return: Search results or error
+        """
+        pattern = args.get("pattern", "").strip()
+        search_path = args.get("path", ".").strip()
+        limit = args.get("limit", DEFAULT_LIMIT)
+        
+        if not pattern:
+            return ToolResult.fail("Error: pattern parameter is required")
+        
+        # Resolve search path
+        absolute_path = self._resolve_path(search_path)
+        
+        if not os.path.exists(absolute_path):
+            return ToolResult.fail(f"Error: Path not found: {search_path}")
+        
+        if not os.path.isdir(absolute_path):
+            return ToolResult.fail(f"Error: Not a directory: {search_path}")
+        
+        try:
+            # Load .gitignore patterns
+            ignore_patterns = self._load_gitignore(absolute_path)
+            
+            # Search for files
+            results = []
+            search_pattern = os.path.join(absolute_path, pattern)
+            
+            # Use glob with recursive support
+            for file_path in glob_module.glob(search_pattern, recursive=True):
+                # Skip if matches ignore patterns
+                if self._should_ignore(file_path, absolute_path, ignore_patterns):
+                    continue
+                
+                # Get relative path
+                relative_path = os.path.relpath(file_path, absolute_path)
+                
+                # Add trailing slash for directories
+                if os.path.isdir(file_path):
+                    relative_path += '/'
+                
+                results.append(relative_path)
+                
+                if len(results) >= limit:
+                    break
+            
+            if not results:
+                return ToolResult.success({"message": "No files found matching pattern", "files": []})
+            
+            # Sort results
+            results.sort()
+            
+            # Format output
+            raw_output = '\n'.join(results)
+            truncation = truncate_head(raw_output, max_lines=999999)  # Only limit by bytes
+            
+            output = truncation.content
+            details = {}
+            notices = []
+            
+            result_limit_reached = len(results) >= limit
+            if result_limit_reached:
+                notices.append(f"{limit} results limit reached. Use limit={limit * 2} for more, or refine pattern")
+                details["result_limit_reached"] = limit
+            
+            if truncation.truncated:
+                notices.append(f"{format_size(DEFAULT_MAX_BYTES)} limit reached")
+                details["truncation"] = truncation.to_dict()
+            
+            if notices:
+                output += f"\n\n[{'. '.join(notices)}]"
+            
+            return ToolResult.success({
+                "output": output,
+                "file_count": len(results),
+                "details": details if details else None
+            })
+            
+        except Exception as e:
+            return ToolResult.fail(f"Error executing find: {str(e)}")
+    
+    def _resolve_path(self, path: str) -> str:
+        """Resolve path to absolute path"""
+        # Expand ~ to user home directory
+        path = os.path.expanduser(path)
+        if os.path.isabs(path):
+            return path
+        return os.path.abspath(os.path.join(self.cwd, path))
+    
+    def _load_gitignore(self, directory: str) -> List[str]:
+        """Load .gitignore patterns from directory"""
+        patterns = []
+        gitignore_path = os.path.join(directory, '.gitignore')
+        
+        if os.path.exists(gitignore_path):
+            try:
+                with open(gitignore_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#'):
+                            patterns.append(line)
+            except:
+                pass
+        
+        # Add common ignore patterns
+        patterns.extend([
+            '.git',
+            '__pycache__',
+            '*.pyc',
+            'node_modules',
+            '.DS_Store'
+        ])
+        
+        return patterns
+    
+    def _should_ignore(self, file_path: str, base_path: str, patterns: List[str]) -> bool:
+        """Check if file should be ignored based on patterns"""
+        relative_path = os.path.relpath(file_path, base_path)
+        
+        for pattern in patterns:
+            # Simple pattern matching
+            if pattern in relative_path:
+                return True
+            
+            # Check if it's a directory pattern
+            if pattern.endswith('/'):
+                if relative_path.startswith(pattern.rstrip('/')):
+                    return True
+        
+        return False