astraagent 2.25.6

package/astra/search.py

@@ -0,0 +1,469 @@
+"""Device Search and File Discovery System - Search entire device for files and directories."""
+
+import os
+import fnmatch
+from pathlib import Path
+from typing import List, Dict, Optional, Set
+from datetime import datetime, timedelta
+
+
+class DeviceSearcher:
+    """Search files and directories across entire device."""
+    
+    # Common root paths for different OS
+    WINDOWS_ROOTS = ['C:\\', 'D:\\', 'E:\\', 'F:\\']
+    LINUX_ROOTS = ['/home', '/root', '/tmp', '/var']
+    MAC_ROOTS = ['/Users', '/tmp', '/var']
+    
+    # Directories to skip (too slow or system dirs)
+    SKIP_DIRS = {
+        '.git', '__pycache__', '.venv', 'venv', 'node_modules',
+        'System Volume Information', '$Recycle.Bin', '.cache',
+        'AppData', 'ProgramData', '.npm', '.config'
+    }
+    
+    # File extensions to search
+    COMMON_EXTENSIONS = {
+        'document': ['.txt', '.md', '.doc', '.docx', '.pdf'],
+        'code': ['.py', '.js', '.ts', '.html', '.css', '.json'],
+        'image': ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'],
+        'video': ['.mp4', '.avi', '.mkv', '.mov', '.webm'],
+        'audio': ['.mp3', '.wav', '.aac', '.flac', '.ogg'],
+        'compressed': ['.zip', '.rar', '.7z', '.tar', '.gz'],
+        'data': ['.csv', '.xlsx', '.xls', '.sql', '.db']
+    }
+    
+    def __init__(self, max_results: int = 100, skip_system: bool = True):
+        """Initialize device searcher.
+        
+        Args:
+            max_results: Maximum number of results to return
+            skip_system: Whether to skip system directories
+        """
+        self.max_results = max_results
+        self.skip_system = skip_system
+        self.paths_searched = 0
+        self.errors = 0
+    
+    def should_skip_dir(self, dir_path: str) -> bool:
+        """Check if directory should be skipped."""
+        if not self.skip_system:
+            return False
+        
+        dir_name = os.path.basename(dir_path)
+        
+        # Skip hidden directories (on Unix)
+        if dir_name.startswith('.') and os.name != 'nt':
+            return True
+        
+        # Skip known system directories
+        for skip in self.SKIP_DIRS:
+            if skip.lower() in dir_path.lower():
+                return True
+        
+        return False
+    
+    def search_by_name(self, filename: str, search_paths: Optional[List[str]] = None,
+                      recursive: bool = True) -> List[str]:
+        """Search for file/directory by name (supports wildcards).
+        
+        Args:
+            filename: Name to search (can use * wildcards)
+            search_paths: Paths to search in. If None, searches common locations
+            recursive: Whether to search recursively
+            
+        Returns:
+            List of matching file paths
+        """
+        if search_paths is None:
+            search_paths = self._get_default_search_paths()
+        
+        results = []
+        self.paths_searched = 0
+        self.errors = 0
+        
+        for search_path in search_paths:
+            if not os.path.exists(search_path):
+                continue
+            
+            if recursive:
+                results.extend(
+                    self._search_recursive(search_path, filename)
+                )
+            else:
+                results.extend(
+                    self._search_single_dir(search_path, filename)
+                )
+            
+            if len(results) >= self.max_results:
+                break
+        
+        return results[:self.max_results]
+    
+    def search_by_extension(self, ext: str, search_paths: Optional[List[str]] = None,
+                           limit: int = 50) -> List[str]:
+        """Search for files by extension.
+        
+        Args:
+            ext: File extension (with or without dot)
+            search_paths: Paths to search
+            limit: Maximum results
+            
+        Returns:
+            List of matching file paths
+        """
+        if not ext.startswith('.'):
+            ext = '.' + ext
+        
+        pattern = f'*{ext}'
+        results = self.search_by_name(pattern, search_paths)
+        return results[:limit]
+    
+    def search_by_category(self, category: str, search_paths: Optional[List[str]] = None,
+                          limit: int = 50) -> List[str]:
+        """Search for files by category (document, code, image, etc).
+        
+        Args:
+            category: File category
+            search_paths: Paths to search
+            limit: Maximum results
+            
+        Returns:
+            List of matching file paths
+        """
+        if category not in self.COMMON_EXTENSIONS:
+            return []
+        
+        results = []
+        extensions = self.COMMON_EXTENSIONS[category]
+        
+        for ext in extensions:
+            results.extend(self.search_by_extension(ext, search_paths, limit))
+        
+        return results[:limit]
+    
+    def search_by_date(self, search_paths: Optional[List[str]] = None,
+                      days_ago: int = 7) -> List[Dict]:
+        """Search for files modified in last N days.
+        
+        Args:
+            search_paths: Paths to search
+            days_ago: Number of days to look back
+            
+        Returns:
+            List of dicts with filepath and modification time
+        """
+        if search_paths is None:
+            search_paths = self._get_default_search_paths()
+        
+        cutoff_time = datetime.now() - timedelta(days=days_ago)
+        results = []
+        
+        for search_path in search_paths:
+            if not os.path.exists(search_path):
+                continue
+            
+            try:
+                for root, dirs, files in os.walk(search_path):
+                    if self.should_skip_dir(root):
+                        dirs.clear()  # Don't descend into skipped dirs
+                        continue
+                    
+                    for file in files:
+                        filepath = os.path.join(root, file)
+                        try:
+                            mtime = datetime.fromtimestamp(os.path.getmtime(filepath))
+                            if mtime > cutoff_time:
+                                results.append({
+                                    'path': filepath,
+                                    'modified': mtime.isoformat(),
+                                    'seconds_ago': int((datetime.now() - mtime).total_seconds())
+                                })
+                            
+                            if len(results) >= self.max_results:
+                                return results
+                        except (OSError, ValueError):
+                            self.errors += 1
+                            continue
+            except Exception:
+                self.errors += 1
+                continue
+        
+        return results
+    
+    def search_by_size(self, search_paths: Optional[List[str]] = None,
+                      min_size: Optional[int] = None,
+                      max_size: Optional[int] = None,
+                      limit: int = 50) -> List[Dict]:
+        """Search for files by size.
+        
+        Args:
+            search_paths: Paths to search
+            min_size: Minimum file size in bytes
+            max_size: Maximum file size in bytes
+            limit: Maximum results
+            
+        Returns:
+            List of dicts with filepath and size
+        """
+        if search_paths is None:
+            search_paths = self._get_default_search_paths()
+        
+        results = []
+        
+        for search_path in search_paths:
+            if not os.path.exists(search_path):
+                continue
+            
+            try:
+                for root, dirs, files in os.walk(search_path):
+                    if self.should_skip_dir(root):
+                        dirs.clear()
+                        continue
+                    
+                    for file in files:
+                        filepath = os.path.join(root, file)
+                        try:
+                            size = os.path.getsize(filepath)
+                            
+                            if min_size and size < min_size:
+                                continue
+                            if max_size and size > max_size:
+                                continue
+                            
+                            results.append({
+                                'path': filepath,
+                                'size': size,
+                                'size_mb': round(size / 1024 / 1024, 2)
+                            })
+                            
+                            if len(results) >= limit:
+                                return results
+                        except (OSError, ValueError):
+                            self.errors += 1
+                            continue
+            except Exception:
+                self.errors += 1
+                continue
+        
+        return results
+    
+    def search_by_content(self, search_text: str, file_types: Optional[List[str]] = None,
+                         search_paths: Optional[List[str]] = None,
+                         limit: int = 30) -> List[Dict]:
+        """Search for text content in files.
+        
+        Args:
+            search_text: Text to search for
+            file_types: File extensions to search in
+            search_paths: Paths to search
+            limit: Maximum results
+            
+        Returns:
+            List of dicts with filepath and match count
+        """
+        if search_paths is None:
+            search_paths = self._get_default_search_paths()
+        
+        if file_types is None:
+            file_types = ['.txt', '.md', '.py', '.js', '.html', '.json', '.csv']
+        
+        results = []
+        
+        for search_path in search_paths:
+            if not os.path.exists(search_path):
+                continue
+            
+            try:
+                for root, dirs, files in os.walk(search_path):
+                    if self.should_skip_dir(root):
+                        dirs.clear()
+                        continue
+                    
+                    for file in files:
+                        if not any(file.endswith(ext) for ext in file_types):
+                            continue
+                        
+                        filepath = os.path.join(root, file)
+                        try:
+                            with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+                                content = f.read()
+                                count = content.lower().count(search_text.lower())
+                                
+                                if count > 0:
+                                    results.append({
+                                        'path': filepath,
+                                        'matches': count,
+                                        'file_size': len(content)
+                                    })
+                                
+                                if len(results) >= limit:
+                                    return results
+                        except (OSError, ValueError):
+                            self.errors += 1
+                            continue
+            except Exception:
+                self.errors += 1
+                continue
+        
+        return results
+    
+    def _search_recursive(self, search_path: str, pattern: str) -> List[str]:
+        """Recursively search directory for files matching pattern."""
+        results = []
+        
+        try:
+            for root, dirs, files in os.walk(search_path):
+                # Remove skipped directories to prevent descending
+                dirs[:] = [d for d in dirs if not self.should_skip_dir(os.path.join(root, d))]
+                
+                self.paths_searched += 1
+                
+                # Search directories
+                for dir_name in dirs:
+                    if fnmatch.fnmatch(dir_name.lower(), pattern.lower()):
+                        results.append(os.path.join(root, dir_name))
+                        if len(results) >= self.max_results:
+                            return results
+                
+                # Search files
+                for file_name in files:
+                    if fnmatch.fnmatch(file_name.lower(), pattern.lower()):
+                        results.append(os.path.join(root, file_name))
+                        if len(results) >= self.max_results:
+                            return results
+        except Exception:
+            self.errors += 1
+        
+        return results
+    
+    def _search_single_dir(self, search_path: str, pattern: str) -> List[str]:
+        """Search single directory (non-recursive) for files matching pattern."""
+        results = []
+        
+        try:
+            for item in os.listdir(search_path):
+                if fnmatch.fnmatch(item.lower(), pattern.lower()):
+                    results.append(os.path.join(search_path, item))
+                    if len(results) >= self.max_results:
+                        return results
+        except Exception:
+            self.errors += 1
+        
+        return results
+    
+    def _get_default_search_paths(self) -> List[str]:
+        """Get default search paths based on OS."""
+        paths = []
+        
+        # Add user home directory (fastest to search)
+        home = Path.home()
+        if home.exists():
+            paths.append(str(home))
+        
+        # Add Desktop, Documents, Downloads
+        for subdir in ['Desktop', 'Documents', 'Downloads', 'OneDrive']:
+            subpath = home / subdir
+            if subpath.exists():
+                paths.append(str(subpath))
+        
+        # Add root paths based on OS
+        current_drive = os.path.splitdrive(os.getcwd())[0]
+        if current_drive:
+            paths.insert(0, current_drive + '\\')
+        
+        return paths
+    
+    def get_directory_contents(self, path: str, show_hidden: bool = False) -> Dict:
+        """Get contents of a directory.
+        
+        Args:
+            path: Directory path
+            show_hidden: Whether to show hidden files
+            
+        Returns:
+            Dict with directories and files
+        """
+        try:
+            if not os.path.isdir(path):
+                return {'error': f'Not a directory: {path}'}
+            
+            dirs = []
+            files = []
+            
+            for item in os.listdir(path):
+                item_path = os.path.join(path, item)
+                
+                # Skip hidden files if requested
+                if not show_hidden and item.startswith('.'):
+                    continue
+                
+                if os.path.isdir(item_path):
+                    dirs.append({
+                        'name': item,
+                        'path': item_path,
+                        'type': 'dir'
+                    })
+                else:
+                    try:
+                        size = os.path.getsize(item_path)
+                        files.append({
+                            'name': item,
+                            'path': item_path,
+                            'type': 'file',
+                            'size': size,
+                            'size_kb': round(size / 1024, 2)
+                        })
+                    except:
+                        pass
+            
+            # Sort
+            dirs.sort(key=lambda x: x['name'].lower())
+            files.sort(key=lambda x: x['name'].lower())
+            
+            return {
+                'path': path,
+                'directories': dirs[:20],  # Limit display
+                'files': files[:20],
+                'total_dirs': len(dirs),
+                'total_files': len(files)
+            }
+        except Exception as e:
+            return {'error': str(e)}
+
+
+def format_search_results(results: List, title: str = "Search Results") -> str:
+    """Format search results for display."""
+    if not results:
+        return f"❌ No results found for: {title}"
+    
+    output = f"\n🔍 {title} ({len(results)} result{'s' if len(results) != 1 else ''}):\n"
+    
+    for i, result in enumerate(results[:20], 1):  # Show max 20
+        if isinstance(result, dict):
+            if 'path' in result:
+                path = result['path']
+                info = []
+                
+                if 'size_mb' in result:
+                    info.append(f"{result['size_mb']} MB")
+                elif 'size_kb' in result:
+                    info.append(f"{result['size_kb']} KB")
+                elif 'size' in result:
+                    info.append(f"{result['size']} bytes")
+                
+                if 'matches' in result:
+                    info.append(f"{result['matches']} matches")
+                
+                if 'modified' in result:
+                    info.append(f"modified {result['seconds_ago']}s ago")
+                
+                info_str = f" [{', '.join(info)}]" if info else ""
+                output += f"  {i}. {path}{info_str}\n"
+        else:
+            output += f"  {i}. {result}\n"
+    
+    if len(results) > 20:
+        output += f"\n  ... and {len(results) - 20} more results\n"
+    
+    return output