Update app/services/reviewer_service.py

app/services/reviewer_service.py

@@ -5,6 +5,8 @@ import hashlib
 import sqlite3
 import threading
 from typing import List
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
 from app.core.model_loader import llm_engine
 
 logger = logging.getLogger(__name__)
@@ -12,7 +14,7 @@ DB_PATH = "review_cache.db"
 
 class AIReviewerService:
     def __init__(self):
-        self.batch_size = 3  # Reduced from 10 to speed up individual prompts
+        self.batch_size = 3
         self.db_lock = threading.Lock()
         self._init_db()
 
@@ -81,29 +83,32 @@ class AIReviewerService:
             logger.info(f"⚡ Served all {len(files)} files instantly from SQLite cache.")
             return results
 
-        # 2. Sequential batch processing (prevents LLM thread lock contention)
+        # 2. Parallel Sub-Batch Processing
         batches = [
             uncached_files[i : i + self.batch_size]
             for i in range(0, len(uncached_files), self.batch_size)
         ]
-        
-        new_results = []
-        for batch in batches:
-            try:
-                batch_results = self._process_batch(batch)
-                new_results.extend(batch_results)
-            except Exception as e:
-                logger.error(f"Batch processing error: {e}")
-                for f_item in batch:
-                    new_results.append({
-                        "fileName": f_item.fileName,
-                        "vulnerabilities": [],
-                        "improvement_suggestions": [],
-                        "metrics": {"complexity": 0, "maintainability": 0},
-                        "error": "analysis_failed",
-                    })
 
-        new_results_map = {item.get("fileName"): item for item in new_results}
+        new_results = []
+        with ThreadPoolExecutor(max_workers=5) as pool:
+            future_to_batch = {pool.submit(self._process_batch, batch): batch for batch in batches}
+            for future in as_completed(future_to_batch):
+                try:
+                    batch_results = future.result()
+                    new_results.extend(batch_results)
+                except Exception as e:
+                    batch = future_to_batch[future]
+                    logger.error(f"Batch processing error: {e}")
+                    for f_item in batch:
+                        new_results.append({
+                            "fileName": f_item.fileName,
+                            "vulnerabilities": [],
+                            "improvement_suggestions": [],
+                            "metrics": {"complexity": 0, "maintainability": 0.0},
+                            "error": str(e),
+                        })
+
+        new_results_map = {item.get("fileName"): item for item in new_results if isinstance(item, dict)}
         to_cache = []
 
         # 3. Assemble final response and update cache
@@ -114,7 +119,7 @@ class AIReviewerService:
                     "fileName": f.fileName,
                     "vulnerabilities": [],
                     "improvement_suggestions": [],
-                    "metrics": {"complexity": 0, "maintainability": 0},
+                    "metrics": {"complexity": 0, "maintainability": 0.0},
                     "error": "analysis_failed",
                 },
             )
@@ -131,25 +136,27 @@ class AIReviewerService:
         file_names = []
         for f in batch:
             raw_content = f.content or ""
-            minified_content = self._minify_code(raw_content[:2000], f.fileName)  # Reduced preview limit to 2000 chars
+            minified_content = self._minify_code(raw_content, f.fileName)
             combined_code += f"\n--- FILE: {f.fileName} ---\n{minified_content}\n"
             file_names.append(f.fileName)
 
         prompt = f"""Analyze {len(batch)} files. Be ultra-concise.
+CRITICAL: The "fileName" field MUST EXACTLY match the file path given in header (e.g. "{file_names[0]}").
+
 {combined_code}
+
 Return ONLY valid JSON array:
 [
   {{
-    "fileName": "name",
+    "fileName": "{file_names[0]}",
     "vulnerabilities": [{{"type": "type", "line": 1, "description": "short", "suggestion": "fix"}}],
     "improvement_suggestions": ["tip"],
-    "metrics": {{"complexity": 3, "maintainability": 8}}
+    "metrics": {{"complexity": 3, "maintainability": 8.0}}
   }}
 ]"""
         batch_results = []
         try:
-            # Capped token length to 1024 max per batch turn
-            response_text = llm_engine.generate(prompt, max_tokens=1024)
+            response_text = llm_engine.generate(prompt, max_tokens=2048)
             parsed = self._parse_json(response_text)
             processed_map = {item.get("fileName"): item for item in parsed if isinstance(item, dict)}
 
@@ -158,14 +165,14 @@ Return ONLY valid JSON array:
                     res = processed_map[fn]
                     res.setdefault("vulnerabilities", [])
                     res.setdefault("improvement_suggestions", [])
-                    res.setdefault("metrics", {"complexity": 5, "maintainability": 5})
+                    res.setdefault("metrics", {"complexity": 5, "maintainability": 5.0})
                     batch_results.append(res)
                 else:
                     batch_results.append({
                         "fileName": fn,
                         "vulnerabilities": [],
                         "improvement_suggestions": [],
-                        "metrics": {"complexity": 1, "maintainability": 10},
+                        "metrics": {"complexity": 1, "maintainability": 10.0},
                     })
         except Exception as e:
             logger.error(f"Batch processing error: {e}")
@@ -174,7 +181,7 @@ Return ONLY valid JSON array:
                     "fileName": fn,
                     "vulnerabilities": [],
                     "improvement_suggestions": [],
-                    "metrics": {"complexity": 0, "maintainability": 0},
+                    "metrics": {"complexity": 0, "maintainability": 0.0},
                     "error": str(e),
                 })
         return batch_results
@@ -183,7 +190,7 @@ Return ONLY valid JSON array:
         lines = code.split("\n")
         cleaned_lines = []
         is_python = filename.endswith(".py")
-        is_js_style = filename.endswith((".js", ".ts", ".jsx", ".tsx"))
+        is_js_style = filename.endswith((".js", ".ts", ".jsx", ".tsx", ".kt", ".java"))
 
         for line in lines:
             stripped = line.strip()
@@ -195,15 +202,22 @@ Return ONLY valid JSON array:
                 continue
             cleaned_lines.append(stripped)
 
-        return "\n".join(cleaned_lines[:50])  # Cap at 50 lines max per file
+        return "\n".join(cleaned_lines)
 
     def _parse_json(self, text: str):
         text = text.strip()
         if not text:
             return []
-        text = re.sub(r"^[^\[]*\[", "[", text)
-        text = re.sub(r"\][^\]]*$", "]", text)
-        text = text.replace("```json", "").replace("```", "").strip()
+
+        # Strip markdown code blocks safely without corrupting string content
+        text = re.sub(r"```(?:json)?", "", text, flags=re.IGNORECASE).strip()
+
+        start_idx = text.find('[')
+        end_idx = text.rfind(']')
+
+        if start_idx != -1 and end_idx != -1 and end_idx > start_idx:
+            text = text[start_idx : end_idx + 1]
+
         try:
             return json.loads(text)
         except json.JSONDecodeError: