Before the refactoring ...

.gitignore

@@ -41,3 +41,6 @@ memory.json
 # OS
 .DS_Store
 Thumbs.db
+
+# Secrets
+.env

agent/tools/api.py

@@ -84,13 +84,6 @@ def find_media_imdb_id(media_title: str) -> Dict[str, Any]:
             "message": str(e)
         }
 
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}", exc_info=True)
-        return {
-            "error": "internal_error",
-            "message": "An unexpected error occurred"
-        }
-
 
 def find_torrent(media_title: str) -> Dict[str, Any]:
     """
@@ -162,13 +155,6 @@ def find_torrent(media_title: str) -> Dict[str, Any]:
             "message": str(e)
         }
 
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}", exc_info=True)
-        return {
-            "error": "internal_error",
-            "message": "An unexpected error occurred"
-        }
-
 
 def add_torrent_to_qbittorrent(magnet_link: str) -> Dict[str, Any]:
     """
@@ -236,10 +222,3 @@ def add_torrent_to_qbittorrent(magnet_link: str) -> Dict[str, Any]:
             "error": "validation_failed",
             "message": str(e)
         }
-
-    except Exception as e:
-        logger.error(f"Unexpected error: {e}", exc_info=True)
-        return {
-            "error": "internal_error",
-            "message": "An unexpected error occurred"
-        }

agent/tools/filesystem.py

@@ -255,3 +255,194 @@ def list_folder(memory: Memory, folder_type: str, path: str = ".") -> Dict[str,
     except Exception as e:
         logger.error(f"Unexpected error listing folder: {e}", exc_info=True)
         return {"error": "internal_error", "message": "Failed to list folder"}
+
+def move_file(path: str, destination: str) -> Dict[str, Any]:
+    """
+    Move a file from one location to another with safety checks.
+
+    This function is designed to safely move files from downloads to movies/series
+    folders with comprehensive validation and error handling to prevent data loss.
+
+    Args:
+        path: Source file path (absolute or relative)
+        destination: Destination file path (absolute or relative)
+
+    Returns:
+        Dict with status or error information:
+        - Success: {"status": "ok", "source": str, "destination": str, "size": int}
+        - Error: {"error": str, "message": str}
+
+    Safety features:
+    - Validates source file exists and is readable
+    - Validates destination directory exists and is writable
+    - Prevents overwriting existing files
+    - Verifies file integrity after move (size check)
+    - Atomic operation using shutil.move
+    - Comprehensive logging
+
+    Example:
+        >>> result = move_file(
+        ...     "/downloads/movie.mkv",
+        ...     "/movies/Inception (2010)/movie.mkv"
+        ... )
+        >>> print(result)
+        {'status': 'ok', 'source': '...', 'destination': '...', 'size': 1234567890}
+    """
+    import shutil
+
+    try:
+        # Convert to Path objects
+        source_path = Path(path).resolve()
+        dest_path = Path(destination).resolve()
+
+        logger.info(f"Moving file from {source_path} to {dest_path}")
+
+        # === VALIDATION: Source file ===
+
+        # Check source exists
+        if not source_path.exists():
+            logger.error(f"Source file does not exist: {source_path}")
+            return {
+                "error": "source_not_found",
+                "message": f"Source file does not exist: {path}"
+            }
+
+        # Check source is a file (not a directory)
+        if not source_path.is_file():
+            logger.error(f"Source is not a file: {source_path}")
+            return {
+                "error": "source_not_file",
+                "message": f"Source is not a file: {path}"
+            }
+
+        # Check source is readable
+        if not os.access(source_path, os.R_OK):
+            logger.error(f"Source file is not readable: {source_path}")
+            return {
+                "error": "permission_denied",
+                "message": f"Source file is not readable: {path}"
+            }
+
+        # Get source file size for verification
+        source_size = source_path.stat().st_size
+        logger.debug(f"Source file size: {source_size} bytes")
+
+        # === VALIDATION: Destination ===
+
+        # Check destination parent directory exists
+        dest_parent = dest_path.parent
+        if not dest_parent.exists():
+            logger.error(f"Destination directory does not exist: {dest_parent}")
+            return {
+                "error": "destination_dir_not_found",
+                "message": f"Destination directory does not exist: {dest_parent}"
+            }
+
+        # Check destination parent is a directory
+        if not dest_parent.is_dir():
+            logger.error(f"Destination parent is not a directory: {dest_parent}")
+            return {
+                "error": "destination_not_dir",
+                "message": f"Destination parent is not a directory: {dest_parent}"
+            }
+
+        # Check destination parent is writable
+        if not os.access(dest_parent, os.W_OK):
+            logger.error(f"Destination directory is not writable: {dest_parent}")
+            return {
+                "error": "permission_denied",
+                "message": f"Destination directory is not writable: {dest_parent}"
+            }
+
+        # Check destination file doesn't already exist
+        if dest_path.exists():
+            logger.warning(f"Destination file already exists: {dest_path}")
+            return {
+                "error": "destination_exists",
+                "message": f"Destination file already exists: {destination}"
+            }
+
+        # === SAFETY CHECK: Prevent moving to same location ===
+
+        if source_path == dest_path:
+            logger.warning("Source and destination are the same")
+            return {
+                "error": "same_location",
+                "message": "Source and destination are the same"
+            }
+
+        # === PERFORM MOVE ===
+
+        logger.info(f"Moving file: {source_path.name} ({source_size} bytes)")
+
+        try:
+            # Use shutil.move for atomic operation
+            # This handles cross-filesystem moves automatically
+            shutil.move(str(source_path), str(dest_path))
+            logger.info(f"File moved successfully to {dest_path}")
+
+        except Exception as e:
+            logger.error(f"Failed to move file: {e}", exc_info=True)
+            return {
+                "error": "move_failed",
+                "message": f"Failed to move file: {str(e)}"
+            }
+
+        # === VERIFICATION: Ensure file was moved correctly ===
+
+        # Check destination file exists
+        if not dest_path.exists():
+            logger.error("Destination file does not exist after move!")
+            # Try to recover by checking if source still exists
+            if source_path.exists():
+                logger.info("Source file still exists, move may have failed")
+                return {
+                    "error": "move_verification_failed",
+                    "message": "File was not moved successfully (destination not found)"
+                }
+            else:
+                logger.critical("Both source and destination missing after move!")
+                return {
+                    "error": "file_lost",
+                    "message": "CRITICAL: File missing after move operation"
+                }
+
+        # Check destination file size matches source
+        dest_size = dest_path.stat().st_size
+        if dest_size != source_size:
+            logger.error(f"File size mismatch! Source: {source_size}, Dest: {dest_size}")
+            return {
+                "error": "size_mismatch",
+                "message": f"File size mismatch after move (expected {source_size}, got {dest_size})"
+            }
+
+        # Check source file no longer exists
+        if source_path.exists():
+            logger.warning("Source file still exists after move (copy instead of move?)")
+            # This is not necessarily an error (shutil.move copies across filesystems)
+            # but we should log it
+
+        # === SUCCESS ===
+
+        logger.info(f"File successfully moved and verified: {dest_path.name}")
+        return {
+            "status": "ok",
+            "source": str(source_path),
+            "destination": str(dest_path),
+            "filename": dest_path.name,
+            "size": dest_size
+        }
+
+    except PermissionError as e:
+        logger.error(f"Permission denied: {e}")
+        return {
+            "error": "permission_denied",
+            "message": f"Permission denied: {str(e)}"
+        }
+
+    except OSError as e:
+        logger.error(f"OS error during move: {e}", exc_info=True)
+        return {
+            "error": "os_error",
+            "message": f"OS error: {str(e)}"
+        }