feat: folder management, document move/drag-drop, per-document chat scoping

app/api/chat.py

@@ -7,7 +7,7 @@ from app.auth import get_current_user
 from app.models import User
 from app.application.chat_service import ChatService
 from app.dependencies import get_chat_service
-from typing import Optional
+from typing import Optional, List
 import logging
 
 logger = logging.getLogger(__name__)
@@ -17,6 +17,9 @@ router = APIRouter(prefix="/chat", tags=["chat"])
 class ChatRequest(BaseModel):
     message: str
     chat_id: Optional[str] = None
+    # Scope the search to specific documents or a folder
+    document_ids: Optional[List[str]] = None  # Ask about specific files
+    folder_id: Optional[str] = None           # Ask about all files in a folder
 
 
 @router.post("/")
@@ -25,19 +28,18 @@ async def send_message(
     chat_service: ChatService = Depends(get_chat_service),
     current_user: User = Depends(get_current_user)
 ):
-    """Send a chat message."""
+    """Send a chat message, optionally scoped to specific documents or a folder."""
     try:
         result = await chat_service.send_message(
             message=request.message,
             user=current_user,
-            chat_id=request.chat_id
+            chat_id=request.chat_id,
+            document_ids=request.document_ids,
+            folder_id=request.folder_id
         )
         return result
     except ValueError as e:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(e)
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
     except Exception as e:
         logger.error(f"Chat error: {e}")
         raise HTTPException(
@@ -65,10 +67,7 @@ async def get_chat_messages(
     try:
         return await chat_service.get_chat_messages(chat_id, current_user)
     except ValueError as e:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(e)
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
 
 
 @router.delete("/{chat_id}")
@@ -82,7 +81,4 @@ async def delete_chat(
         await chat_service.delete_chat(chat_id, current_user)
         return {"message": "Chat deleted successfully"}
     except ValueError as e:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=str(e)
-        )
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(e))

app/api/documents.py

@@ -1,13 +1,14 @@
 """Documents API endpoints."""
 from fastapi import APIRouter, Depends, UploadFile, File, Form, HTTPException, status
+from pydantic import BaseModel
 from sqlalchemy.orm import Session
 from app.database import get_db
 from app.auth import get_current_user
-from app.models import User
+from app.models import User, Document
 from app.application.document_service import DocumentService
 from app.dependencies import get_document_service
 from app.config import get_settings
-from typing import Optional, List
+from typing import Optional
 import logging
 
 logger = logging.getLogger(__name__)
@@ -15,6 +16,10 @@ router = APIRouter(prefix="/documents", tags=["documents"])
 settings = get_settings()
 
 
+class MoveDocumentRequest(BaseModel):
+    folder_id: Optional[str] = None  # None = move to root
+
+
 @router.post("/upload")
 async def upload_document(
     file: UploadFile = File(...),
@@ -91,6 +96,42 @@ async def list_documents(
     ]
 
 
+@router.patch("/{document_id}/move")
+async def move_document(
+    document_id: str,
+    request: MoveDocumentRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Move a document to a folder or to root (drag & drop support)."""
+    document = db.query(Document).filter(
+        Document.id == document_id,
+        Document.org_id == current_user.org_id
+    ).first()
+    if not document:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Document not found")
+
+    # Validate folder belongs to same org
+    if request.folder_id:
+        from app.models import Folder
+        folder = db.query(Folder).filter(
+            Folder.id == request.folder_id,
+            Folder.org_id == current_user.org_id
+        ).first()
+        if not folder:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
+
+    document.folder_id = request.folder_id
+    db.commit()
+
+    return {
+        "id": document.id,
+        "name": document.name,
+        "folder_id": document.folder_id,
+        "message": "Document moved successfully"
+    }
+
+
 @router.delete("/{document_id}")
 async def delete_document(
     document_id: str,

app/api/folders.py

@@ -1,35 +1,54 @@
 """Folders API endpoints."""
 from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
 from sqlalchemy.orm import Session
 from app.database import get_db
 from app.auth import get_current_user
-from app.models import User, Folder
+from app.models import User, Folder, Document
+from typing import Optional
 import logging
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/folders", tags=["folders"])
 
 
-@router.post("/")
+class CreateFolderRequest(BaseModel):
+    name: str
+
+
+class RenameFolderRequest(BaseModel):
+    name: str
+
+
+class MoveDocumentRequest(BaseModel):
+    document_id: str
+    folder_id: Optional[str] = None  # None = move to root
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
 async def create_folder(
-    name: str,
+    request: CreateFolderRequest,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
-    """Create a folder."""
-    folder = Folder(
-        name=name,
-        org_id=current_user.org_id
-    )
+    """Create a new folder."""
+    # Check for duplicate name in same org
+    existing = db.query(Folder).filter(
+        Folder.org_id == current_user.org_id,
+        Folder.name == request.name
+    ).first()
+    if existing:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Folder '{request.name}' already exists"
+        )
+
+    folder = Folder(name=request.name, org_id=current_user.org_id)
     db.add(folder)
     db.commit()
     db.refresh(folder)
-    
-    return {
-        "id": folder.id,
-        "name": folder.name,
-        "created_at": folder.created_at.isoformat()
-    }
+
+    return _folder_response(folder, db)
 
 
 @router.get("/")
@@ -37,40 +56,164 @@ async def list_folders(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
-    """List all folders."""
+    """List all folders with document counts."""
     folders = db.query(Folder).filter(
         Folder.org_id == current_user.org_id
     ).order_by(Folder.created_at.desc()).all()
-    
-    return [
-        {
-            "id": folder.id,
-            "name": folder.name,
-            "created_at": folder.created_at.isoformat()
-        }
-        for folder in folders
-    ]
+
+    return [_folder_response(f, db) for f in folders]
+
+
+@router.get("/{folder_id}")
+async def get_folder(
+    folder_id: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Get a folder with its documents."""
+    folder = _get_folder_or_404(folder_id, current_user.org_id, db)
+
+    documents = db.query(Document).filter(
+        Document.folder_id == folder_id,
+        Document.org_id == current_user.org_id
+    ).order_by(Document.created_at.desc()).all()
+
+    return {
+        **_folder_response(folder, db),
+        "documents": [_doc_response(d) for d in documents]
+    }
+
+
+@router.patch("/{folder_id}")
+async def rename_folder(
+    folder_id: str,
+    request: RenameFolderRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Rename a folder."""
+    folder = _get_folder_or_404(folder_id, current_user.org_id, db)
+
+    # Check duplicate name
+    existing = db.query(Folder).filter(
+        Folder.org_id == current_user.org_id,
+        Folder.name == request.name,
+        Folder.id != folder_id
+    ).first()
+    if existing:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Folder '{request.name}' already exists"
+        )
+
+    folder.name = request.name
+    db.commit()
+    db.refresh(folder)
+
+    return _folder_response(folder, db)
+
+
+@router.post("/{folder_id}/move-document")
+async def move_document_to_folder(
+    folder_id: str,
+    request: MoveDocumentRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Move a document into this folder (supports drag & drop)."""
+    _get_folder_or_404(folder_id, current_user.org_id, db)
+
+    document = db.query(Document).filter(
+        Document.id == request.document_id,
+        Document.org_id == current_user.org_id
+    ).first()
+    if not document:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Document not found")
+
+    document.folder_id = folder_id
+    db.commit()
+
+    return {"message": "Document moved successfully", "document_id": request.document_id, "folder_id": folder_id}
+
+
+@router.delete("/{folder_id}/move-document")
+async def remove_document_from_folder(
+    folder_id: str,
+    request: MoveDocumentRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """Remove a document from a folder (move to root)."""
+    document = db.query(Document).filter(
+        Document.id == request.document_id,
+        Document.org_id == current_user.org_id,
+        Document.folder_id == folder_id
+    ).first()
+    if not document:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Document not found in this folder")
+
+    document.folder_id = None
+    db.commit()
+
+    return {"message": "Document removed from folder", "document_id": request.document_id}
 
 
 @router.delete("/{folder_id}")
 async def delete_folder(
     folder_id: str,
+    force: bool = False,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
-    """Delete a folder."""
-    folder = db.query(Folder).filter(
-        Folder.id == folder_id,
-        Folder.org_id == current_user.org_id
-    ).first()
-    
-    if not folder:
+    """Delete a folder. Use ?force=true to also move documents to root."""
+    folder = _get_folder_or_404(folder_id, current_user.org_id, db)
+
+    doc_count = db.query(Document).filter(Document.folder_id == folder_id).count()
+
+    if doc_count > 0 and not force:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Folder not found"
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Folder has {doc_count} document(s). Use ?force=true to delete and move documents to root."
         )
-    
+
+    if force:
+        # Move all documents to root
+        db.query(Document).filter(Document.folder_id == folder_id).update({"folder_id": None})
+
     db.delete(folder)
     db.commit()
-    
+
     return {"message": "Folder deleted successfully"}
+
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _get_folder_or_404(folder_id: str, org_id: str, db: Session) -> Folder:
+    folder = db.query(Folder).filter(
+        Folder.id == folder_id,
+        Folder.org_id == org_id
+    ).first()
+    if not folder:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Folder not found")
+    return folder
+
+
+def _folder_response(folder: Folder, db: Session) -> dict:
+    doc_count = db.query(Document).filter(Document.folder_id == folder.id).count()
+    return {
+        "id": folder.id,
+        "name": folder.name,
+        "document_count": doc_count,
+        "created_at": folder.created_at.isoformat()
+    }
+
+
+def _doc_response(doc: Document) -> dict:
+    return {
+        "id": doc.id,
+        "name": doc.name,
+        "size": doc.size,
+        "chunks": doc.chunks,
+        "folder_id": doc.folder_id,
+        "created_at": doc.created_at.isoformat()
+    }

app/application/chat_service.py

@@ -32,11 +32,13 @@ class ChatService:
         self,
         message: str,
         user: User,
-        chat_id: Optional[str] = None
+        chat_id: Optional[str] = None,
+        document_ids: Optional[List[str]] = None,
+        folder_id: Optional[str] = None
     ) -> Dict[str, Any]:
         """Send message and get AI response."""
         logger.info(f"Processing message for user {user.email}")
-        
+
         # Get or create chat
         if chat_id:
             chat = self.db.query(Chat).filter(
@@ -46,37 +48,41 @@ class ChatService:
             if not chat:
                 raise ValueError("Chat not found")
         else:
-            # Create new chat with first message as title
             title = message[:50] + "..." if len(message) > 50 else message
-            chat = Chat(
-                title=title,
-                user_id=user.id,
-                org_id=user.org_id
-            )
+            chat = Chat(title=title, user_id=user.id, org_id=user.org_id)
             self.db.add(chat)
             self.db.commit()
             self.db.refresh(chat)
-        
+
         # Store user message
-        user_message = Message(
-            chat_id=chat.id,
-            role="user",
-            content=message
-        )
+        user_message = Message(chat_id=chat.id, role="user", content=message)
         self.db.add(user_message)
         self.db.commit()
-        
+
+        # Resolve document_ids from folder if folder_id provided
+        if folder_id and not document_ids:
+            docs = self.db.query(Document).filter(
+                Document.folder_id == folder_id,
+                Document.org_id == user.org_id
+            ).all()
+            document_ids = [d.id for d in docs]
+            if not document_ids:
+                answer = f"The selected folder has no documents yet. Please upload files to it first."
+                self._save_assistant_message(chat.id, answer, [])
+                return {"answer": answer, "sources": [], "chat_id": chat.id}
+
         # 1. Embed query
         query_embedding = await self.embedder.embed_text(message)
-        
-        # 2. Search vector DB
+
+        # 2. Search vector DB (scoped or global)
         search_results = await self.vector_db.search(
             query_embedding=query_embedding,
             org_id=user.org_id,
             top_k=settings.TOP_K_RETRIEVAL,
-            collection_name=settings.QDRANT_COLLECTION
+            collection_name=settings.QDRANT_COLLECTION,
+            document_ids=document_ids  # None = search all docs
         )
-        
+
         # 3. Build context and sources
         context_chunks = [result.text for result in search_results]
         sources = [
@@ -88,38 +94,45 @@ class ChatService:
             }
             for result in search_results
         ]
-        
+
         # 4. Get chat history
         chat_history = self._get_chat_history(chat.id)
-        
+
         # 5. Generate answer
         if not context_chunks:
-            answer = "I cannot find any relevant information in your documents. Please upload documents related to your question."
+            if document_ids:
+                answer = "I couldn't find relevant information in the selected document(s). Try asking a different question or select different files."
+            else:
+                answer = "I cannot find any relevant information in your documents. Please upload documents related to your question."
         else:
+            # Add scope context to the question if scoped
+            scoped_question = message
+            if document_ids:
+                doc_names = list({s["document_name"] for s in sources})
+                scoped_question = f"[Searching in: {', '.join(doc_names)}]\n\n{message}"
+
             llm_response = await self.llm.generate_answer(
-                question=message,
+                question=scoped_question,
                 context_chunks=context_chunks,
                 chat_history=chat_history
             )
             answer = llm_response.answer
-        
+
         # 6. Store assistant message
+        self._save_assistant_message(chat.id, answer, sources)
+
+        logger.info(f"Generated response for chat {chat.id}")
+        return {"answer": answer, "sources": sources, "chat_id": chat.id}
+
+    def _save_assistant_message(self, chat_id: str, answer: str, sources: list):
         assistant_message = Message(
-            chat_id=chat.id,
+            chat_id=chat_id,
             role="assistant",
             content=answer,
             sources=json.dumps(sources)
         )
         self.db.add(assistant_message)
         self.db.commit()
-        
-        logger.info(f"Generated response for chat {chat.id}")
-        
-        return {
-            "answer": answer,
-            "sources": sources,
-            "chat_id": chat.id
-        }
     
     def _get_chat_history(self, chat_id: str) -> List[LLMMessage]:
         """Get recent chat history."""

app/ports/vector_db.py

@@ -44,7 +44,8 @@ class VectorDBPort(ABC):
         query_embedding: List[float],
         org_id: str,
         top_k: int,
-        collection_name: str
+        collection_name: str,
+        document_ids: List[str] = None  # None = search all docs
     ) -> List[VectorSearchResult]:
         """Search for similar vectors."""
         pass

app/services/pinecone_adapter.py

@@ -106,18 +106,29 @@ class PineconeAdapter(VectorDBPort):
         query_embedding: List[float],
         org_id: str,
         top_k: int,
-        collection_name: str
+        collection_name: str,
+        document_ids: List[str] = None
     ) -> List[VectorSearchResult]:
         """Search for similar vectors in Pinecone."""
         if self.index is None:
             raise RuntimeError("Pinecone client not available")
-        
+
         try:
-            # Query Pinecone with org_id filter
+            # Build filter
+            if document_ids:
+                # Scope to specific documents
+                pinecone_filter = {
+                    "org_id": {"$eq": org_id},
+                    "document_id": {"$in": document_ids}
+                }
+            else:
+                # Search all docs in org
+                pinecone_filter = {"org_id": {"$eq": org_id}}
+
             results = self.index.query(
                 vector=query_embedding,
                 top_k=top_k,
-                filter={"org_id": {"$eq": org_id}},
+                filter=pinecone_filter,
                 include_metadata=True
             )