astraagent 2.25.6

package/astra/tasks.py

@@ -0,0 +1,466 @@
+"""Task Execution System - Perform various system tasks from chat."""
+
+import os
+import subprocess
+import shutil
+import json
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+
+class TaskExecutor:
+    """Execute various system and file tasks."""
+    
+    @staticmethod
+    def open_file(filepath: str) -> Dict[str, str]:
+        """Open a file with default application.
+        
+        Args:
+            filepath: Path to file
+            
+        Returns:
+            Status dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            if not os.path.exists(filepath):
+                return {'success': False, 'message': f'File not found: {filepath}'}
+            
+            if os.name == 'nt':  # Windows
+                os.startfile(filepath)
+            elif os.name == 'posix':  # Linux/Mac
+                import subprocess
+                subprocess.Popen(['xdg-open' if os.uname()[0] == 'Linux' else 'open', filepath])
+            
+            return {'success': True, 'message': f'Opening: {filepath}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def open_folder(folder_path: str) -> Dict[str, str]:
+        """Open folder in file explorer.
+        
+        Args:
+            folder_path: Path to folder
+            
+        Returns:
+            Status dict
+        """
+        try:
+            folder_path = os.path.abspath(folder_path)
+            if not os.path.isdir(folder_path):
+                return {'success': False, 'message': f'Folder not found: {folder_path}'}
+            
+            if os.name == 'nt':  # Windows
+                os.startfile(folder_path)
+            elif os.name == 'posix':  # Linux/Mac
+                subprocess.Popen(['xdg-open' if os.uname()[0] == 'Linux' else 'open', folder_path])
+            
+            return {'success': True, 'message': f'Opening folder: {folder_path}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def copy_file(source: str, dest: str) -> Dict[str, str]:
+        """Copy file from source to destination.
+        
+        Args:
+            source: Source file path
+            dest: Destination file path
+            
+        Returns:
+            Status dict
+        """
+        try:
+            source = os.path.abspath(source)
+            dest = os.path.abspath(dest)
+            
+            if not os.path.exists(source):
+                return {'success': False, 'message': f'Source file not found: {source}'}
+            
+            # Create destination directory if needed
+            dest_dir = os.path.dirname(dest)
+            if dest_dir and not os.path.exists(dest_dir):
+                os.makedirs(dest_dir, exist_ok=True)
+            
+            shutil.copy2(source, dest)
+            return {'success': True, 'message': f'Copied: {source} → {dest}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def move_file(source: str, dest: str) -> Dict[str, str]:
+        """Move file from source to destination.
+        
+        Args:
+            source: Source file path
+            dest: Destination file path
+            
+        Returns:
+            Status dict
+        """
+        try:
+            source = os.path.abspath(source)
+            dest = os.path.abspath(dest)
+            
+            if not os.path.exists(source):
+                return {'success': False, 'message': f'File not found: {source}'}
+            
+            # Create destination directory if needed
+            dest_dir = os.path.dirname(dest)
+            if dest_dir and not os.path.exists(dest_dir):
+                os.makedirs(dest_dir, exist_ok=True)
+            
+            shutil.move(source, dest)
+            return {'success': True, 'message': f'Moved: {source} → {dest}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def delete_file(filepath: str, confirm: bool = True) -> Dict[str, str]:
+        """Delete a file.
+        
+        Args:
+            filepath: Path to file
+            confirm: Whether to require confirmation
+            
+        Returns:
+            Status dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            
+            if not os.path.exists(filepath):
+                return {'success': False, 'message': f'File not found: {filepath}'}
+            
+            if not os.path.isfile(filepath):
+                return {'success': False, 'message': f'Not a file: {filepath}'}
+            
+            os.remove(filepath)
+            return {'success': True, 'message': f'Deleted: {filepath}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def create_folder(folder_path: str) -> Dict[str, str]:
+        """Create a new folder.
+        
+        Args:
+            folder_path: Path to create
+            
+        Returns:
+            Status dict
+        """
+        try:
+            folder_path = os.path.abspath(folder_path)
+            
+            if os.path.exists(folder_path):
+                return {'success': False, 'message': f'Folder already exists: {folder_path}'}
+            
+            os.makedirs(folder_path, exist_ok=True)
+            return {'success': True, 'message': f'Created folder: {folder_path}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def delete_folder(folder_path: str, recursive: bool = False) -> Dict[str, str]:
+        """Delete a folder.
+        
+        Args:
+            folder_path: Path to folder
+            recursive: Whether to delete recursively (all contents)
+            
+        Returns:
+            Status dict
+        """
+        try:
+            folder_path = os.path.abspath(folder_path)
+            
+            if not os.path.isdir(folder_path):
+                return {'success': False, 'message': f'Folder not found: {folder_path}'}
+            
+            if recursive:
+                shutil.rmtree(folder_path)
+            else:
+                os.rmdir(folder_path)
+            
+            return {'success': True, 'message': f'Deleted folder: {folder_path}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def get_file_info(filepath: str) -> Dict[str, Any]:
+        """Get detailed information about a file.
+        
+        Args:
+            filepath: Path to file
+            
+        Returns:
+            Details dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            
+            if not os.path.exists(filepath):
+                return {'error': f'File not found: {filepath}'}
+            
+            stat = os.stat(filepath)
+            path_obj = Path(filepath)
+            
+            return {
+                'path': filepath,
+                'name': os.path.basename(filepath),
+                'exists': True,
+                'is_file': os.path.isfile(filepath),
+                'is_dir': os.path.isdir(filepath),
+                'size': stat.st_size,
+                'size_mb': round(stat.st_size / 1024 / 1024, 2),
+                'created': datetime.fromtimestamp(stat.st_ctime).isoformat(),
+                'modified': datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                'extension': path_obj.suffix,
+                'parent': str(path_obj.parent)
+            }
+        except Exception as e:
+            return {'error': str(e)}
+    
+    @staticmethod
+    def rename_file(filepath: str, new_name: str) -> Dict[str, str]:
+        """Rename a file.
+        
+        Args:
+            filepath: Path to file
+            new_name: New filename
+            
+        Returns:
+            Status dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            
+            if not os.path.exists(filepath):
+                return {'success': False, 'message': f'File not found: {filepath}'}
+            
+            directory = os.path.dirname(filepath)
+            new_path = os.path.join(directory, new_name)
+            
+            if os.path.exists(new_path):
+                return {'success': False, 'message': f'File already exists: {new_path}'}
+            
+            os.rename(filepath, new_path)
+            return {'success': True, 'message': f'Renamed: {filepath} → {new_path}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def list_directory(dirpath: str, show_hidden: bool = False) -> Dict[str, Any]:
+        """List contents of a directory.
+        
+        Args:
+            dirpath: Path to directory
+            show_hidden: Whether to show hidden files
+            
+        Returns:
+            Contents dict
+        """
+        try:
+            dirpath = os.path.abspath(dirpath)
+            
+            if not os.path.isdir(dirpath):
+                return {'error': f'Not a directory: {dirpath}'}
+            
+            dirs = []
+            files = []
+            
+            for item in sorted(os.listdir(dirpath)):
+                if not show_hidden and item.startswith('.'):
+                    continue
+                
+                item_path = os.path.join(dirpath, item)
+                
+                if os.path.isdir(item_path):
+                    dirs.append({
+                        'name': item,
+                        'path': item_path,
+                        'type': 'directory'
+                    })
+                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
+            
+            return {
+                'path': dirpath,
+                'directories': dirs,
+                'files': files,
+                'total_items': len(dirs) + len(files)
+            }
+        except Exception as e:
+            return {'error': str(e)}
+    
+    @staticmethod
+    def search_and_replace_in_file(filepath: str, search_text: str, 
+                                   replace_text: str, backup: bool = True) -> Dict[str, str]:
+        """Search and replace text in a file.
+        
+        Args:
+            filepath: Path to file
+            search_text: Text to find
+            replace_text: Replacement text
+            backup: Whether to create backup
+            
+        Returns:
+            Status dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            
+            if not os.path.exists(filepath):
+                return {'success': False, 'message': f'File not found: {filepath}'}
+            
+            # Read file
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Count replacements
+            count = content.count(search_text)
+            
+            if count == 0:
+                return {'success': False, 'message': f'Text not found: {search_text}'}
+            
+            # Backup if requested
+            if backup:
+                backup_path = filepath + '.backup'
+                shutil.copy2(filepath, backup_path)
+            
+            # Replace
+            new_content = content.replace(search_text, replace_text)
+            
+            # Write back
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            
+            msg = f'Replaced {count} occurrence{"s" if count != 1 else ""} in {filepath}'
+            if backup:
+                msg += f'\nBackup created: {backup_path}'
+            
+            return {'success': True, 'message': msg}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def create_file(filepath: str, content: str = "") -> Dict[str, str]:
+        """Create a new file with optional content.
+        
+        Args:
+            filepath: Path to create
+            content: Initial content
+            
+        Returns:
+            Status dict
+        """
+        try:
+            filepath = os.path.abspath(filepath)
+            
+            if os.path.exists(filepath):
+                return {'success': False, 'message': f'File already exists: {filepath}'}
+            
+            # Create parent directories if needed
+            parent_dir = os.path.dirname(filepath)
+            if parent_dir and not os.path.exists(parent_dir):
+                os.makedirs(parent_dir, exist_ok=True)
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            
+            return {'success': True, 'message': f'Created file: {filepath}'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error: {str(e)}'}
+    
+    @staticmethod
+    def get_disk_usage(path: str = "/") -> Dict[str, Any]:
+        """Get disk usage information.
+        
+        Args:
+            path: Path to check (root by default)
+            
+        Returns:
+            Usage dict
+        """
+        try:
+            path = os.path.abspath(path)
+            
+            if os.name == 'nt':  # Windows
+                import ctypes
+                free_bytes = ctypes.c_ulonglong(0)
+                ctypes.windll.kernel32.GetDiskFreeSpaceExW(ctypes.c_wchar_p(path), 
+                                                            free_bytes, None, None)
+                free = free_bytes.value
+                
+                # Get total (approximate)
+                stat = os.statvfs(os.path.splitdrive(path)[0] + '\\') if hasattr(os, 'statvfs') else None
+                if stat:
+                    total = stat.f_blocks * stat.f_frsize
+                else:
+                    total = None
+            else:  # Unix/Linux
+                stat = os.statvfs(path)
+                free = stat.f_bavail * stat.f_frsize
+                total = stat.f_blocks * stat.f_frsize
+            
+            return {
+                'path': path,
+                'free_gb': round(free / 1024 / 1024 / 1024, 2) if free else None,
+                'free_bytes': free,
+                'total_gb': round(total / 1024 / 1024 / 1024, 2) if total else None,
+                'total_bytes': total
+            }
+        except Exception as e:
+            return {'error': str(e)}
+
+
+def format_task_result(result: Dict) -> str:
+    """Format task result for display."""
+    if isinstance(result, dict):
+        if 'error' in result:
+            return f"❌ Error: {result['error']}"
+        
+        if 'success' in result:
+            status = "✅" if result['success'] else "❌"
+            return f"{status} {result.get('message', 'Task completed')}"
+        
+        if 'path' in result and 'is_file' in result:
+            # File info
+            output = f"\n📄 File Info: {result['name']}\n"
+            output += f"   Path: {result['path']}\n"
+            output += f"   Size: {result['size_mb']} MB ({result['size']} bytes)\n"
+            output += f"   Modified: {result['modified']}\n"
+            return output
+        
+        if 'directories' in result and 'files' in result:
+            # Directory listing
+            output = f"\n📁 Directory: {result['path']}\n"
+            output += f"   Folders: {len(result['directories'])}\n"
+            output += f"   Files: {len(result['files'])}\n"
+            
+            if result['directories']:
+                output += "\n   Folders:\n"
+                for d in result['directories'][:10]:
+                    output += f"     📂 {d['name']}\n"
+            
+            if result['files']:
+                output += "\n   Files:\n"
+                for f in result['files'][:10]:
+                    output += f"     📄 {f['name']} ({f['size_kb']} KB)\n"
+            
+            return output
+    
+    return str(result)

package/astra/tools/__init__.py

@@ -0,0 +1,17 @@
+"""Tools module for AstraAgent."""
+
+from astra.tools.base import Tool, ToolResult, ToolRegistry
+from astra.tools.shell import ShellTool
+from astra.tools.file import FileReadTool, FileWriteTool, ListDirTool
+from astra.tools.python import PythonTool
+from astra.tools.web import WebSearchTool, WebFetchTool
+from astra.tools.browser import BrowserTool
+from astra.tools.git import GitTool
+from astra.tools.memory_tool import MemoryTool
+
+__all__ = [
+    "Tool", "ToolResult", "ToolRegistry",
+    "ShellTool", "FileReadTool", "FileWriteTool", "ListDirTool",
+    "PythonTool", "WebSearchTool", "WebFetchTool", "BrowserTool",
+    "GitTool", "MemoryTool"
+]