Update app/main.py

app/main.py

@@ -16,8 +16,9 @@ import uvicorn
 load_dotenv()
 
 # Import internal services
-# Note: Ensure these modules exist in your /app directory
+# Ensure these modules exist in your /app directory
 from app.predictor import classifier, guide_generator, reviewer
+from app.core.model_loader import llm_engine
 
 # 1. Setup Logging
 logging.basicConfig(level=logging.INFO)
@@ -25,7 +26,6 @@ logger = logging.getLogger(__name__)
 
 # 2. Initialize FastAPI
 app = FastAPI(title="GitGud AI Service")
-main = app # Alias for compatibility
 
 # Global embedding cache
 # Structure: { "repo_name": { "file_path": [embedding_vector] } }
@@ -46,15 +46,29 @@ class GuideRequest(BaseModel):
 
 class SearchRequest(BaseModel):
     query: str
-    embeddings: Optional[Dict[str, List[float]]] = None  # Path -> Embedding
+    embeddings: Optional[Dict[str, List[float]]] = None
     repoName: Optional[str] = None
 
 class ChatRequest(BaseModel):
     query: str
-    context: List[Dict[str, str]]  # List of { "fileName": str, "content": str }
+    context: List[Dict[str, str]]
     repoName: str
 
-# 4. Endpoints
+# 4. Core Logic Helpers
+def calculate_repo_health(total_vulns: int, avg_maint: float) -> int:
+    """
+    Standardized health logic to keep Dashboard and Review metrics in sync.
+    Uses a weighted scale of maintainability vs security risk.
+    """
+    # Base starts from the maintainability average (0.0 to 10.0 scale mapped to 100)
+    base_score = avg_maint * 10
+    # Penalty: Subtract 8 points per vulnerability
+    penalty = total_vulns * 8
+    
+    final_score = base_score - penalty
+    return int(max(10, min(100, final_score)))
+
+# 5. Endpoints
 
 @app.get("/")
 def health_check():
@@ -68,8 +82,7 @@ def health_check():
 
 @app.get("/usage")
 def get_usage():
-    """Returns AI Service usage statistics."""
-    from app.core.model_loader import llm_engine
+    """Returns AI Service usage statistics from the LLM engine."""
     return llm_engine.get_usage_stats()
 
 @app.post("/classify")
@@ -95,77 +108,65 @@ async def classify_file(request: FileRequest):
 
 @app.post("/review-batch-code")
 async def review_batch_code(request: BatchReviewRequest):
-    """Batch review with detailed metrics and suggestions."""
+    """Detailed review results for the Review Section UI."""
     try:
         reviews = reviewer.service.review_batch_code(request.files)
-        total_files = len(reviews)
-        total_vulns = sum(len(r.get("vulnerabilities", [])) for r in reviews)
-        
-        m_scores = [r.get("metrics", {}).get("maintainability", 8) for r in reviews]
-        avg_maint = sum(m_scores) / max(total_files, 1)
-
-        return {
-            "totalFiles": total_files,
-            "totalVulnerabilities": total_vulns,
-            "averageMaintainability": round(avg_maint, 1),
-            "results": reviews,
-        }
+        return {"results": reviews}
     except Exception as e:
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/repo-dashboard-stats")
 async def get_dashboard_stats(request: BatchReviewRequest):
-    """Aggregated stats using parallel processing for speed and review-first logic."""
+    """Aggregated stats using the exact same logic as batch review."""
     try:
-        # 1. Run the heavy AI review process in a thread pool to prevent blocking
+        # Run heavy AI review in thread pool to keep FastAPI responsive
         loop = asyncio.get_event_loop()
         with ThreadPoolExecutor() as executor:
             raw_reviews = await loop.run_in_executor(
                 executor, reviewer.service.review_batch_code, request.files
             )
 
-        # 2. Extract Data from the Review Results
         total_vulns = 0
         maint_scores = []
         found_apis = set()
         api_regex = re.compile(r'(?:get|post|put|delete|patch)\([\'"]\/(.*?)[\'"]', re.IGNORECASE)
 
         for i, review in enumerate(raw_reviews):
-            # Security Count from Review
+            # Sync Vulnerability count
             vulns = review.get("vulnerabilities", [])
             total_vulns += len(vulns)
             
-            # Maintainability Score
-            m_score = review.get("metrics", {}).get("maintainability", 8)
+            # Sync Maintainability
+            m_score = review.get("metrics", {}).get("maintainability", 8.0)
             maint_scores.append(m_score)
             
-            # API Sniffing
+            # Extract APIs (No cap, show all discovered)
             content = request.files[i].content
             if content:
                 matches = api_regex.findall(content)
                 for match in matches:
                     found_apis.add(f"/{match}")
 
-        # 3. Aggregation & Calculations
         num_files = len(maint_scores)
         avg_maint = (sum(maint_scores) / num_files) if num_files > 0 else 0
         
-        # Health Calculation: Base 100, -12 per vulnerability
-        health_score = max(10, 100 - (total_vulns * 12))
+        # Calculate health using shared logic
+        health_score = calculate_repo_health(total_vulns, avg_maint)
 
         return {
             "repo_health": health_score,
             "health_label": "Excellent" if health_score > 85 else "Good" if health_score > 60 else "Critical",
             "security_issues": total_vulns,
             "performance_ratio": f"{int(avg_maint * 10)}%",
-            "exposed_apis": list(found_apis)[:12],
-            "total_files_processed": num_files
+            "exposed_apis": list(found_apis),
+            "total_files_processed": num_files,
+            "average_maintainability": round(avg_maint, 1)
         }
     except Exception as e:
         logger.error(f"Dashboard stats failed: {e}")
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail="Failed to aggregate repository stats")
+        raise HTTPException(status_code=500, detail="Failed to sync dashboard metrics")
 
 @app.post("/analyze-file")
 async def analyze_file(request: FileRequest):
@@ -175,11 +176,6 @@ async def analyze_file(request: FileRequest):
         summary = classifier.generate_file_summary(request.content, request.fileName)
         tags = classifier.extract_tags(request.content, request.fileName)
 
-        if request.repoName:
-            if request.repoName not in REPO_CACHE:
-                REPO_CACHE[request.repoName] = {}
-            REPO_CACHE[request.repoName][request.fileName] = result["embedding"]
-
         return {
             "fileName": request.fileName,
             "layer": result["label"],
@@ -213,17 +209,14 @@ async def chat(request: ChatRequest):
     """RAG-based chat using provided file context."""
     start_time = time.time()
     try:
-        from app.core.model_loader import llm_engine
-        
         context_str = ""
         for item in request.context:
             context_str += f"--- FILE: {item['fileName']} ---\n{item['content']}\n\n"
         
-        has_context = len(request.context) > 0
         prompt = f"""
         You are "GitGud AI", an expert software architect.
         Repository: "{request.repoName}"
-        CONTEXT: {context_str if has_context else "(NO CODE PROVIDED)"}
+        CONTEXT: {context_str if request.context else "(NO CODE PROVIDED)"}
         USER QUESTION: {request.query}
         """
         response = llm_engine.generate_text(prompt)
@@ -244,7 +237,7 @@ async def generate_guide(request: GuideRequest):
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=str(e))
 
-# 5. Application Entry Point
+# 6. Application Entry Point
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     uvicorn.run(app, host="0.0.0.0", port=port)