Align knowledge storage with real folders and add WebDAV import surface

Knowledge files were only partitioned in the database, which made nested uploads, local folder visibility, and delete behavior diverge from the UI. This change makes folder selection drive physical storage paths, keeps original filenames, adds a minimal WebDAV mount/sync path, and reshapes the knowledge panel so local and remote sources can share the same surface.

Constraint: Existing knowledge flow already depends on local-folder-backed uploads and document indexing
Rejected: Real-time bidirectional WebDAV sync | too much conflict and lifecycle complexity for the first pass
Confidence: medium
Scope-risk: moderate
Reversibility: messy
Directive: Keep remote mounts single-direction into local knowledge folders until etag-based incremental sync and conflict rules are verified
Tested: Python py_compile on new/modified backend files; LSP diagnostics on new frontend/backend files; manual targeted code-path inspection
Not-tested: Full pytest/vitest end-to-end runs blocked by environment temp/cache permission errors; live WebDAV server interoperability

backend/app/services/document_service.py

@@ -5,6 +5,7 @@
 
 from pathlib import Path
 import tempfile
+import shutil
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from fastapi import UploadFile
@@ -18,7 +19,6 @@ import json
 import os
 import re
 import aiofiles
-import uuid
 from dataclasses import dataclass, field
 
 
@@ -52,9 +52,9 @@ class DocumentService:
         if ext not in ALLOWED_EXTENSIONS:
             raise ValueError(f"不支持的文件类型: {ext}")
 
-        os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
-        file_id = str(uuid.uuid4())
-        file_path = os.path.join(settings.UPLOAD_DIR, f"{file_id}{ext}")
+        folder_path = await self._get_storage_directory(user_id, folder_id)
+        folder_path.mkdir(parents=True, exist_ok=True)
+        file_path = self._resolve_unique_file_path(folder_path, file.filename)
 
         content = await file.read()
         file_size = len(content)
@@ -64,7 +64,7 @@ class DocumentService:
         async with aiofiles.open(file_path, "wb") as f:
             await f.write(content)
 
-        parsed = await self._parse_document(file_path, ext)
+        parsed = await self._parse_document(str(file_path), ext)
         parsed.structured_markdown = self._render_structured_markdown(parsed)
 
         doc = Document(
@@ -73,7 +73,7 @@ class DocumentService:
             filename=file.filename,
             file_type=ext[1:],
             file_size=file_size,
-            file_path=file_path,
+            file_path=str(file_path),
             summary=parsed.summary[:500] if len(parsed.summary) > 500 else parsed.summary,
             folder_id=folder_id,
             ingestion_status="uploaded",
@@ -171,6 +171,83 @@ class DocumentService:
 
         return "/" + "/".join(path_parts) if path_parts else None
 
+    async def ensure_folder_directory(self, user_id: str, folder_id: str | None) -> Path:
+        folder_path = await self._get_storage_directory(user_id, folder_id)
+        folder_path.mkdir(parents=True, exist_ok=True)
+        return folder_path
+
+    async def delete_folder_directory(self, user_id: str, folder_id: str) -> None:
+        folder_path = await self._get_storage_directory(user_id, folder_id)
+        if folder_path.exists():
+            shutil.rmtree(folder_path, ignore_errors=True)
+
+    async def rename_folder_directory(self, user_id: str, folder_id: str, old_name: str, new_name: str) -> None:
+        folder = await self.db.get(Folder, folder_id)
+        if folder is None:
+            return
+
+        parent_path = await self._get_storage_directory(user_id, folder.parent_id)
+        old_path = parent_path / self._sanitize_storage_name(old_name)
+        new_path = parent_path / self._sanitize_storage_name(new_name)
+
+        if old_path != new_path:
+            parent_path.mkdir(parents=True, exist_ok=True)
+            if old_path.exists():
+                old_path.rename(new_path)
+            else:
+                new_path.mkdir(parents=True, exist_ok=True)
+        else:
+            new_path.mkdir(parents=True, exist_ok=True)
+
+        document_result = await self.db.execute(
+            select(Document).where(Document.user_id == user_id)
+        )
+        for document in document_result.scalars().all():
+            try:
+                relative_path = Path(document.file_path).relative_to(old_path)
+            except ValueError:
+                continue
+            document.file_path = str(new_path / relative_path)
+
+    async def _get_storage_directory(self, user_id: str, folder_id: str | None) -> Path:
+        base_path = Path(settings.UPLOAD_DIR) / user_id
+        if not folder_id:
+            return base_path
+
+        folders = await self.db.execute(
+            select(Folder).where(Folder.user_id == user_id)
+        )
+        folder_map = {folder.id: folder for folder in folders.scalars().all()}
+
+        path_segments: list[str] = []
+        current_id = folder_id
+        while current_id:
+            folder = folder_map.get(current_id)
+            if folder is None:
+                raise ValueError("鐖舵枃浠跺す涓嶅瓨鍦?")
+            path_segments.insert(0, self._sanitize_storage_name(folder.name))
+            current_id = folder.parent_id
+
+        return base_path.joinpath(*path_segments)
+
+    def _resolve_unique_file_path(self, directory: Path, original_name: str) -> Path:
+        safe_name = self._sanitize_storage_name(Path(original_name).name, is_file=True)
+        stem = Path(safe_name).stem
+        suffix = Path(safe_name).suffix
+        candidate = directory / safe_name
+        counter = 2
+        while candidate.exists():
+            candidate = directory / f"{stem}-{counter}{suffix}"
+            counter += 1
+        return candidate
+
+    def _sanitize_storage_name(self, name: str, is_file: bool = False) -> str:
+        invalid_chars = '<>:"/\\|?*'
+        sanitized = ''.join('_' if char in invalid_chars or ord(char) < 32 else char for char in name).strip().rstrip('.')
+        if not sanitized:
+            return 'untitled' if is_file else 'folder'
+        return sanitized
+
     async def delete_document(self, user_id: str, document_id: str):
         result = await self.db.execute(
             select(Document).where(