feat: add recipe root directory and move recipe endpoints

- Add GET /api/lm/recipes/roots endpoint to retrieve recipe root directories
- Add POST /api/lm/recipe/move endpoint to move recipes between directories
- Register new endpoints in route definitions
- Implement error handling for both new endpoints with proper status codes
- Enable recipe management operations for better file organization

py/routes/handlers/recipe_handlers.py

@@ -56,6 +56,7 @@ class RecipeHandlerSet:
             "delete_recipe": self.management.delete_recipe,
             "get_top_tags": self.query.get_top_tags,
             "get_base_models": self.query.get_base_models,
+            "get_roots": self.query.get_roots,
             "get_folders": self.query.get_folders,
             "get_folder_tree": self.query.get_folder_tree,
             "get_unified_folder_tree": self.query.get_unified_folder_tree,
@@ -69,6 +70,7 @@ class RecipeHandlerSet:
             "save_recipe_from_widget": self.management.save_recipe_from_widget,
             "get_recipes_for_lora": self.query.get_recipes_for_lora,
             "scan_recipes": self.query.scan_recipes,
+            "move_recipe": self.management.move_recipe,
         }
 
 
@@ -306,6 +308,19 @@ class RecipeQueryHandler:
             self._logger.error("Error retrieving base models: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    async def get_roots(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            roots = [recipe_scanner.recipes_dir] if recipe_scanner.recipes_dir else []
+            return web.json_response({"success": True, "roots": roots})
+        except Exception as exc:
+            self._logger.error("Error retrieving recipe roots: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def get_folders(self, request: web.Request) -> web.Response:
         try:
             await self._ensure_dependencies_ready()
@@ -591,6 +606,35 @@ class RecipeManagementHandler:
             self._logger.error("Error updating recipe: %s", exc, exc_info=True)
             return web.json_response({"error": str(exc)}, status=500)
 
+    async def move_recipe(self, request: web.Request) -> web.Response:
+        try:
+            await self._ensure_dependencies_ready()
+            recipe_scanner = self._recipe_scanner_getter()
+            if recipe_scanner is None:
+                raise RuntimeError("Recipe scanner unavailable")
+
+            data = await request.json()
+            recipe_id = data.get("recipe_id")
+            target_path = data.get("target_path")
+            if not recipe_id or not target_path:
+                return web.json_response(
+                    {"success": False, "error": "recipe_id and target_path are required"}, status=400
+                )
+
+            result = await self._persistence_service.move_recipe(
+                recipe_scanner=recipe_scanner,
+                recipe_id=str(recipe_id),
+                target_path=str(target_path),
+            )
+            return web.json_response(result.payload, status=result.status)
+        except RecipeValidationError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=400)
+        except RecipeNotFoundError as exc:
+            return web.json_response({"success": False, "error": str(exc)}, status=404)
+        except Exception as exc:
+            self._logger.error("Error moving recipe: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def reconnect_lora(self, request: web.Request) -> web.Response:
         try:
             await self._ensure_dependencies_ready()

py/routes/recipe_route_registrar.py

@@ -27,6 +27,7 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("DELETE", "/api/lm/recipe/{recipe_id}", "delete_recipe"),
     RouteDefinition("GET", "/api/lm/recipes/top-tags", "get_top_tags"),
     RouteDefinition("GET", "/api/lm/recipes/base-models", "get_base_models"),
+    RouteDefinition("GET", "/api/lm/recipes/roots", "get_roots"),
     RouteDefinition("GET", "/api/lm/recipes/folders", "get_folders"),
     RouteDefinition("GET", "/api/lm/recipes/folder-tree", "get_folder_tree"),
     RouteDefinition("GET", "/api/lm/recipes/unified-folder-tree", "get_unified_folder_tree"),
@@ -34,6 +35,7 @@ ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/share/download", "download_shared_recipe"),
     RouteDefinition("GET", "/api/lm/recipe/{recipe_id}/syntax", "get_recipe_syntax"),
     RouteDefinition("PUT", "/api/lm/recipe/{recipe_id}/update", "update_recipe"),
+    RouteDefinition("POST", "/api/lm/recipe/move", "move_recipe"),
     RouteDefinition("POST", "/api/lm/recipe/lora/reconnect", "reconnect_lora"),
     RouteDefinition("GET", "/api/lm/recipes/find-duplicates", "find_duplicates"),
     RouteDefinition("POST", "/api/lm/recipes/bulk-delete", "bulk_delete"),

py/services/recipe_scanner.py

@@ -1246,6 +1246,30 @@ class RecipeScanner:
         from datetime import datetime
         return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
 
+    async def get_recipe_json_path(self, recipe_id: str) -> Optional[str]:
+        """Locate the recipe JSON file, accounting for folder placement."""
+
+        recipes_dir = self.recipes_dir
+        if not recipes_dir:
+            return None
+
+        cache = await self.get_cached_data()
+        folder = ""
+        for item in cache.raw_data:
+            if str(item.get("id")) == str(recipe_id):
+                folder = item.get("folder") or ""
+                break
+
+        candidate = os.path.normpath(os.path.join(recipes_dir, folder, f"{recipe_id}.recipe.json"))
+        if os.path.exists(candidate):
+            return candidate
+
+        for root, _, files in os.walk(recipes_dir):
+            if f"{recipe_id}.recipe.json" in files:
+                return os.path.join(root, f"{recipe_id}.recipe.json")
+
+        return None
+
     async def update_recipe_metadata(self, recipe_id: str, metadata: dict) -> bool:
         """Update recipe metadata (like title and tags) in both file system and cache
         
@@ -1256,13 +1280,9 @@ class RecipeScanner:
         Returns:
             bool: True if successful, False otherwise
         """
-        import os
-        import json
-        
         # First, find the recipe JSON file path
-        recipe_json_path = os.path.join(self.recipes_dir, f"{recipe_id}.recipe.json")
-        
-        if not os.path.exists(recipe_json_path):
+        recipe_json_path = await self.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
             return False
             
         try:
@@ -1311,8 +1331,8 @@ class RecipeScanner:
         if target_name is None:
             raise ValueError("target_name must be provided")
 
-        recipe_json_path = os.path.join(self.recipes_dir, f"{recipe_id}.recipe.json")
-        if not os.path.exists(recipe_json_path):
+        recipe_json_path = await self.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
             raise RecipeNotFoundError("Recipe not found")
 
         async with self._mutation_lock:

py/services/recipes/persistence_service.py

@@ -5,6 +5,7 @@ import base64
 import json
 import os
 import re
+import shutil
 import time
 import uuid
 from dataclasses import dataclass
@@ -154,12 +155,8 @@ class RecipePersistenceService:
     async def delete_recipe(self, *, recipe_scanner, recipe_id: str) -> PersistenceResult:
         """Delete an existing recipe."""
 
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir or not os.path.exists(recipes_dir):
-            raise RecipeNotFoundError("Recipes directory not found")
-
-        recipe_json_path = os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-        if not os.path.exists(recipe_json_path):
+        recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
             raise RecipeNotFoundError("Recipe not found")
 
         with open(recipe_json_path, "r", encoding="utf-8") as file_obj:
@@ -187,6 +184,83 @@ class RecipePersistenceService:
 
         return PersistenceResult({"success": True, "recipe_id": recipe_id, "updates": updates})
 
+    async def move_recipe(self, *, recipe_scanner, recipe_id: str, target_path: str) -> PersistenceResult:
+        """Move a recipe's assets into a new folder under the recipes root."""
+
+        if not target_path:
+            raise RecipeValidationError("Target path is required")
+
+        recipes_root = recipe_scanner.recipes_dir
+        if not recipes_root:
+            raise RecipeNotFoundError("Recipes directory not found")
+
+        normalized_target = os.path.normpath(target_path)
+        recipes_root = os.path.normpath(recipes_root)
+        if not os.path.isabs(normalized_target):
+            normalized_target = os.path.normpath(os.path.join(recipes_root, normalized_target))
+
+        try:
+            common_root = os.path.commonpath([normalized_target, recipes_root])
+        except ValueError as exc:
+            raise RecipeValidationError("Invalid target path") from exc
+
+        if common_root != recipes_root:
+            raise RecipeValidationError("Target path must be inside the recipes directory")
+
+        recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_json_path or not os.path.exists(recipe_json_path):
+            raise RecipeNotFoundError("Recipe not found")
+
+        recipe_data = await recipe_scanner.get_recipe_by_id(recipe_id)
+        if not recipe_data:
+            raise RecipeNotFoundError("Recipe not found")
+
+        current_json_dir = os.path.dirname(recipe_json_path)
+        normalized_image_path = os.path.normpath(recipe_data.get("file_path") or "") if recipe_data.get("file_path") else None
+
+        os.makedirs(normalized_target, exist_ok=True)
+
+        if os.path.normpath(current_json_dir) == normalized_target:
+            return PersistenceResult(
+                {
+                    "success": True,
+                    "message": "Recipe is already in the target folder",
+                    "recipe_id": recipe_id,
+                    "original_file_path": recipe_data.get("file_path"),
+                    "new_file_path": recipe_data.get("file_path"),
+                }
+            )
+
+        new_json_path = os.path.normpath(os.path.join(normalized_target, os.path.basename(recipe_json_path)))
+        shutil.move(recipe_json_path, new_json_path)
+
+        new_image_path = normalized_image_path
+        if normalized_image_path:
+            target_image_path = os.path.normpath(os.path.join(normalized_target, os.path.basename(normalized_image_path)))
+            if os.path.exists(normalized_image_path) and normalized_image_path != target_image_path:
+                shutil.move(normalized_image_path, target_image_path)
+            new_image_path = target_image_path
+
+        relative_folder = os.path.relpath(normalized_target, recipes_root)
+        if relative_folder in (".", ""):
+            relative_folder = ""
+        updates = {"file_path": new_image_path or recipe_data.get("file_path"), "folder": relative_folder.replace(os.path.sep, "/")}
+
+        updated = await recipe_scanner.update_recipe_metadata(recipe_id, updates)
+        if not updated:
+            raise RecipeNotFoundError("Recipe not found after move")
+
+        return PersistenceResult(
+            {
+                "success": True,
+                "recipe_id": recipe_id,
+                "original_file_path": recipe_data.get("file_path"),
+                "new_file_path": updates["file_path"],
+                "json_path": new_json_path,
+                "folder": updates["folder"],
+            }
+        )
+
     async def reconnect_lora(
         self,
         *,
@@ -197,8 +271,8 @@ class RecipePersistenceService:
     ) -> PersistenceResult:
         """Reconnect a LoRA entry within an existing recipe."""
 
-        recipe_path = os.path.join(recipe_scanner.recipes_dir, f"{recipe_id}.recipe.json")
-        if not os.path.exists(recipe_path):
+        recipe_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+        if not recipe_path or not os.path.exists(recipe_path):
             raise RecipeNotFoundError("Recipe not found")
 
         target_lora = await recipe_scanner.get_local_lora(target_name)
@@ -243,16 +317,12 @@ class RecipePersistenceService:
         if not recipe_ids:
             raise RecipeValidationError("No recipe IDs provided")
 
-        recipes_dir = recipe_scanner.recipes_dir
-        if not recipes_dir or not os.path.exists(recipes_dir):
-            raise RecipeNotFoundError("Recipes directory not found")
-
         deleted_recipes: list[str] = []
         failed_recipes: list[dict[str, Any]] = []
 
         for recipe_id in recipe_ids:
-            recipe_json_path = os.path.join(recipes_dir, f"{recipe_id}.recipe.json")
-            if not os.path.exists(recipe_json_path):
+            recipe_json_path = await recipe_scanner.get_recipe_json_path(recipe_id)
+            if not recipe_json_path or not os.path.exists(recipe_json_path):
                 failed_recipes.append({"id": recipe_id, "reason": "Recipe not found"})
                 continue