Update app/main.py

app/main.py

@@ -56,8 +56,12 @@ class ChatRequest(BaseModel):
 def calculate_repo_health(total_vulns: int, avg_maint: float) -> int:
     base_score = avg_maint * 10
     penalty = total_vulns * 8
-    final_score = base_score - penalty
-    return int(max(10, min(100, final_score)))
+    return int(max(10, min(100, base_score - penalty)))
+
+def sync_review_worker(file_req: FileRequest):
+    """Wrapper for the synchronous reviewer service"""
+    # Note: We pass the individual file object directly
+    return reviewer.service.review_batch_code([file_req])
 
 def parse_tree_to_list(raw_tree: str):
     """Parses text tree into JSON objects for Compose LazyColumn"""
@@ -112,75 +116,62 @@ async def classify_file(request: FileRequest):
 @app.post("/review-batch-code")
 async def review_batch_code(request: BatchReviewRequest):
     try:
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         
-        # Helper function to process one file at a time, WITH the fix to unwrap the list
-        def process_single_file(file_req):
-            return reviewer.service.review_batch_code([file_req])
-
-        # Spin up a ThreadPoolExecutor with up to 15 concurrent workers
-        with ThreadPoolExecutor(max_workers=15) as executor:
-            # Create a concurrent task for every file in the request
-            tasks = [
-                loop.run_in_executor(executor, process_single_file, f) 
-                for f in request.files
-            ]
-            
-            # asyncio.gather fires them all off at the exact same time
-            raw_reviews = await asyncio.gather(*tasks, return_exceptions=True)
+        # Dispatch all files to the thread pool immediately
+        tasks = [
+            loop.run_in_executor(executor, sync_review_worker, f) 
+            for f in request.files
+        ]
+        
+        # Wait for all to complete
+        raw_results = await asyncio.gather(*tasks, return_exceptions=True)
 
-        # Clean up the results and handle any individual file failures gracefully
-        valid_reviews = []
-        for i, result in enumerate(raw_reviews):
+        final_reviews = []
+        for i, result in enumerate(raw_results):
             if isinstance(result, Exception):
-                # If we hit a rate limit, bubble it up immediately
-                if "429" in str(result):
-                    raise HTTPException(status_code=429, detail="AI Quota Exceeded")
-                
-                # Otherwise, log the specific file error but don't crash the whole batch
-                logger.error(f"Failed to analyze {request.files[i].fileName}: {result}")
+                logger.error(f"Error reviewing {request.files[i].fileName}: {result}")
+                # We return a placeholder error for this specific file so the UI knows it failed
+                final_reviews.append({
+                    "fileName": request.files[i].fileName,
+                    "error": "Analysis failed",
+                    "details": str(result)
+                })
             else:
-                valid_reviews.append(result)
+                final_reviews.append(result)
 
-        return {"results": valid_reviews}
+        return {"results": final_reviews}
 
     except Exception as e:
-        if isinstance(e, HTTPException):
-            raise e
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Batch review critical failure: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail="Internal processing error")
 
 @app.post("/repo-dashboard-stats")
 async def get_dashboard_stats(request: BatchReviewRequest):
     try:
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         
-        # 1. Use the same parallel helper for blazing fast stats!
-        def process_single_file(file_req):
-            return reviewer.service.review_batch_code([file_req])
-
-        # 2. Run all files concurrently
-        with ThreadPoolExecutor(max_workers=15) as executor:
-            tasks = [
-                loop.run_in_executor(executor, process_single_file, f) 
-                for f in request.files
-            ]
-            raw_reviews = await asyncio.gather(*tasks, return_exceptions=True)
+        # Parallel execution for stats
+        tasks = [loop.run_in_executor(executor, sync_review_worker, f) for f in request.files]
+        raw_reviews = await asyncio.gather(*tasks, return_exceptions=True)
 
         total_vulns = 0
         maint_scores = []
         found_apis = set()
         api_regex = re.compile(r'(?:get|post|put|delete|patch)\([\'"]\/(.*?)[\'"]', re.IGNORECASE)
 
-        # 3. Process the results, ignoring any parallel tasks that failed
         for i, review in enumerate(raw_reviews):
             if isinstance(review, Exception):
-                logger.error(f"Skipping stats for {request.files[i].fileName} due to error: {review}")
-                continue # Skip failed files so the dashboard doesn't crash
+                continue 
 
-            vulns = review.get("vulnerabilities", [])
+            # Handle the structure returned by your reviewer service
+            # (Assuming it returns a list or a dict based on your current service)
+            current_review = review[0] if isinstance(review, list) else review
+            
+            vulns = current_review.get("vulnerabilities", [])
             total_vulns += len(vulns)
-            m_score = review.get("metrics", {}).get("maintainability", 8.0)
+            
+            m_score = current_review.get("metrics", {}).get("maintainability", 8.0)
             maint_scores.append(m_score)
             
             content = request.files[i].content
@@ -203,10 +194,8 @@ async def get_dashboard_stats(request: BatchReviewRequest):
             "average_maintainability": round(avg_maint, 1)
         }
     except Exception as e:
-        if "429" in str(e):
-            raise HTTPException(status_code=429, detail="Quota exceeded")
-        logger.error(f"Dashboard stats failed: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail="Failed to sync dashboard metrics")
+        logger.error(f"Stats failed: {e}")
+        raise HTTPException(status_code=500, detail="Failed to aggregate metrics")
 
 @app.post("/analyze-file")
 async def analyze_file(request: FileRequest):