fix: actually start background analysis task and implement process_analysis in AnalysisService

app/api/routes/analysis.py

@@ -1,7 +1,7 @@
 """
 Routes analyses K2 Think
 """
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status, BackgroundTasks, Response, FileResponse
 from sqlalchemy.orm import Session
 from app.dependencies import get_db, get_current_user
 from app.services.analysis_service import AnalysisService
@@ -18,7 +18,6 @@ from app.models.schemas import ScientificDocument, AnalysisRequest as K2Analysis
 from app.services.export_service import ExportService
 from app.services.arxiv_service import ArXivService
 from app.services.openalex_service import OpenAlexService
-from fastapi.responses import Response, FileResponse
 from app.core.logging import logger
 
 router = APIRouter()
@@ -49,10 +48,12 @@ async def get_user_analysis_history(
     return results
 
 
+
 @router.post("/{project_id}", response_model=dict, status_code=status.HTTP_202_ACCEPTED)
 async def start_project_analysis(
     project_id: str,
     request: AnalysisRequest,
+    background_tasks: BackgroundTasks,
     current_user = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
@@ -90,6 +91,13 @@ async def start_project_analysis(
             project_id=target_project_id,
             model_used=request.model or "k2-think-pro"
         )
+
+        # START THE ACTUAL PROCESSING
+        background_tasks.add_task(
+            service.process_analysis,
+            str(analysis.id),
+            request
+        )
         
         return {
             "message": "Analysis started successfully",

app/services/analysis_service.py

@@ -33,6 +33,7 @@ class AnalysisService:
     def complete_analysis(
         self,
         analysis_id: UUID,
+        result: dict = None,
         status: str = "COMPLETED"
     ):
         """Marque une analyse comme complétée"""
@@ -41,6 +42,65 @@ class AnalysisService:
         if analysis:
             analysis.status = status
             analysis.completed_at = datetime.utcnow()
+            if result:
+                analysis.result_data = json.dumps(result)
             self.analysis_repo.update(analysis_id, analysis)
         
         return analysis
+
+    async def process_analysis(self, analysis_id: str, request):
+        """Tâche de fond pour traiter l'analyse"""
+        from app.services.k2_think_engine import K2ThinkEngine
+        from app.db.repositories.paper_repo import PaperRepository
+        from app.models.schemas import K2AnalysisRequest, ScientificDocument
+        from app.db.models.reasoning_trace import ReasoningTrace
+        
+        db = self.analysis_repo.db
+        try:
+            # 1. Fetch papers from DB
+            paper_repo = PaperRepository(db)
+            db_papers = [paper_repo.get_by_id(pid) for pid in request.paper_ids]
+            
+            docs = []
+            for p in db_papers:
+                if p:
+                    docs.append(ScientificDocument(
+                        id=str(p.id),
+                        title=p.title,
+                        abstract=p.summary or "",
+                        content=p.summary or "", # TODO: Full text if available
+                        url=p.pdf_path or ""
+                    ))
+
+            # 2. Prepare K2 Request
+            k2_req = K2AnalysisRequest(
+                documents=docs,
+                user_id=request.user_id,
+                user_profile=request.user_profile,
+                reasoning_depth=request.reasoning_depth,
+                ethics_rigor=request.ethics_rigor,
+                info_density=request.info_density
+            )
+
+            # 3. Call K2 Engine
+            engine = K2ThinkEngine()
+            result = await engine.process_analysis_request(k2_req)
+
+            # 4. Save Reasoning Trace
+            trace = ReasoningTrace(
+                analysis_id=UUID(analysis_id),
+                trace_data=json.dumps(result.get("reasoning_steps", [])),
+                final_conclusion=result.get("strategic_recommendations", ""),
+                tokens_used=0 
+            )
+            db.add(trace)
+            
+            # 5. Complete Analysis
+            self.complete_analysis(UUID(analysis_id), result=result)
+            db.commit()
+
+        except Exception as e:
+            from app.core.logging import logger
+            logger.error(f"Background analysis error for {analysis_id}: {e}")
+            self.complete_analysis(UUID(analysis_id), status="FAILED")
+            db.commit()