hello

analyzer.py

@@ -38,44 +38,159 @@ def analyze_code(code: str) -> str:
     return response.choices[0].message.content
 
 def parse_llm_json_response(response: str):
+    """
+    Robust JSON parser with multiple fallback strategies for LLM responses.
+    """
+    logger.info(f"Attempting to parse LLM response: {response[:100]}...")
+    
+    # Strategy 1: Try direct JSON parsing (cleanest case)
+    try:
+        # Clean the response first
+        cleaned = response.strip()
+        result = json.loads(cleaned)
+        logger.info("✅ Direct JSON parsing successful")
+        return result
+    except:
+        pass
+    
+    # Strategy 2: Extract JSON block from response
     try:
-        print("DEBUGGGGG ::: ", response)
+        # Find the first complete JSON object
+        start = response.find('{')
+        if start == -1:
+            raise ValueError("No opening brace found")
+        
+        # Find matching closing brace
+        brace_count = 0
+        end = start
+        for i, char in enumerate(response[start:], start):
+            if char == '{':
+                brace_count += 1
+            elif char == '}':
+                brace_count -= 1
+                if brace_count == 0:
+                    end = i
+                    break
+        
+        if brace_count != 0:
+            # Fallback to last closing brace
+            end = response.rfind('}')
+            if end == -1 or end < start:
+                raise ValueError("No matching closing brace found")
         
-        # 1. Extract the JSON object part of the string
+        json_str = response[start:end+1]
+        result = json.loads(json_str)
+        logger.info("✅ JSON block extraction successful")
+        return result
+    except Exception as e:
+        logger.warning(f"JSON block extraction failed: {e}")
+    
+    # Strategy 3: Clean and fix common JSON issues
+    try:
+        # Extract JSON part
         start = response.find('{')
         end = response.rfind('}')
-        if start == -1 or end == -1 or end < start:
-            raise ValueError("No valid JSON object found in the response.")
-        json_str = response[start:end+1]
-
-        # 2. Replace single quotes used for keys/values with double quotes.
-        # This handles cases like {'key': 'value'}
-        json_str = re.sub(r"'", '"', json_str)
-
-        # 3. Find all string values and escape any unescaped double quotes inside them.
-        # This uses a function as the replacement in re.sub
-        def escape_inner_quotes(match):
-            # The match object gives us the full string matched by the regex.
-            # We take the part between the outer quotes (group 1)
-            # and replace any \" with a temporary unique placeholder.
-            # Then, we replace any remaining " with \", and finally
-            # restore the original escaped quotes.
-            inner_content = match.group(1)
-            placeholder = "___TEMP_QUOTE___"
-            inner_content = inner_content.replace('\\"', placeholder)
-            inner_content = inner_content.replace('"', '\\"')
-            inner_content = inner_content.replace(placeholder, '\\"')
-            return f'"{inner_content}"'
-
-        # This regex finds a double quote, captures everything until the next double quote,
-        # and then applies the function to that captured group.
-        json_str = re.sub(r'"(.*?)"', escape_inner_quotes, json_str)
+        if start != -1 and end != -1 and end > start:
+            json_str = response[start:end+1]
+            
+            # Fix common issues
+            # Replace single quotes with double quotes (but be careful with contractions)
+            json_str = re.sub(r"(?<!\\)'([^']*)'(?=\s*[,}])", r'"\1"', json_str)
+            json_str = re.sub(r"(?<!\\)'([^']*)'(?=\s*:)", r'"\1"', json_str)
+            
+            # Fix unescaped quotes in values
+            json_str = re.sub(r':\s*"([^"]*)"([^",}]*)"', r': "\1\2"', json_str)
+            
+            # Remove trailing commas
+            json_str = re.sub(r',(\s*[}\]])', r'\1', json_str)
+            
+            # Try parsing the cleaned version
+            result = json.loads(json_str)
+            logger.info("✅ JSON cleaning and fixing successful")
+            return result
+    except Exception as e:
+        logger.warning(f"JSON cleaning failed: {e}")
+    
+    # Strategy 4: Manual field extraction as last resort
+    try:
+        logger.info("Attempting manual field extraction...")
+        result = {}
         
-        return json.loads(json_str)
+        # Extract each field using regex patterns
+        patterns = {
+            'strength': [
+                r'"strength"\s*:\s*"([^"]*)"',
+                r"'strength'\s*:\s*'([^']*)'",
+                r'strength[:\s]+"([^"]*)"',
+                r'strength[:\s]+\'([^\']*)\''
+            ],
+            'weaknesses': [
+                r'"weaknesses"\s*:\s*"([^"]*)"',
+                r"'weaknesses'\s*:\s*'([^']*)'",
+                r'weaknesses[:\s]+"([^"]*)"',
+                r'weaknesses[:\s]+\'([^\']*)\''
+            ],
+            'speciality': [
+                r'"speciality"\s*:\s*"([^"]*)"',
+                r"'speciality'\s*:\s*'([^']*)'",
+                r'speciality[:\s]+"([^"]*)"',
+                r'speciality[:\s]+\'([^\']*)\''
+            ],
+            'relevance rating': [
+                r'"relevance rating"\s*:\s*"([^"]*)"',
+                r"'relevance rating'\s*:\s*'([^']*)'",
+                r'relevance[^:]*rating[:\s]+"([^"]*)"',
+                r'relevance[^:]*rating[:\s]+\'([^\']*)\''
+            ]
+        }
+        
+        for field, field_patterns in patterns.items():
+            found = False
+            for pattern in field_patterns:
+                match = re.search(pattern, response, re.IGNORECASE | re.DOTALL)
+                if match:
+                    value = match.group(1).strip()
+                    # Clean up the extracted value
+                    value = re.sub(r'\\+(["\'])', r'\1', value)  # Remove excessive escaping
+                    value = value.replace('\\"', '"').replace("\\'", "'")
+                    result[field] = value
+                    found = True
+                    break
+            
+            if not found:
+                result[field] = ""
+        
+        # Validate relevance rating
+        valid_ratings = ['very low', 'low', 'high', 'very high']
+        if result.get('relevance rating', '').lower() not in [r.lower() for r in valid_ratings]:
+            # Try to fix common variations
+            rating = result.get('relevance rating', '').lower()
+            if 'very' in rating and 'low' in rating:
+                result['relevance rating'] = 'very low'
+            elif 'very' in rating and 'high' in rating:
+                result['relevance rating'] = 'very high'
+            elif 'low' in rating:
+                result['relevance rating'] = 'low'
+            elif 'high' in rating:
+                result['relevance rating'] = 'high'
+            else:
+                result['relevance rating'] = 'low'  # Default fallback
+        
+        logger.info("✅ Manual field extraction successful")
+        return result
         
     except Exception as e:
-        print("DEBUGGGGG error ::: ", e)
-        return {"error": f"Failed to parse JSON: {e}", "raw": response}
+        logger.warning(f"Manual extraction failed: {e}")
+    
+    # Strategy 5: Complete fallback with empty values
+    logger.error("All JSON parsing strategies failed, returning empty structure")
+    return {
+        "strength": "Analysis could not be completed - please try again",
+        "weaknesses": "Analysis could not be completed - please try again", 
+        "speciality": "Analysis could not be completed - please try again",
+        "relevance rating": "low",
+        "error": f"Failed to parse LLM response after all strategies. Raw: {response[:200]}..."
+    }
 
 def combine_repo_files_for_llm(repo_dir="repo_files", output_file="combined_repo.txt"):
     """

app.py

@@ -1036,12 +1036,13 @@ def create_ui() -> gr.Blocks:
                 return gr.update(visible=False), hf_url
             return gr.update(visible=False), ""
 
-        def handle_explore_repo(repo_id: str) -> Tuple[Any, Any]:
-            """Handle navigating to the repo explorer - simple version."""
-            logger.info(f"Switching to repo explorer tab")
+        def handle_explore_repo(repo_id: str) -> Tuple[Any, Any, Any]:
+            """Handle navigating to the repo explorer and setting the repo ID."""
+            logger.info(f"Switching to repo explorer tab with repo: {repo_id}")
             return (
                 gr.update(visible=False),  # close modal
-                gr.update(selected="repo_explorer_tab")  # switch tab
+                gr.update(selected="repo_explorer_tab"),  # switch tab
+                gr.update(value=repo_id if repo_id else "")  # set repo ID
             )
 
         def handle_cancel_modal() -> Any:
@@ -1192,7 +1193,8 @@ def create_ui() -> gr.Blocks:
             inputs=[selected_repo_display],
             outputs=[
                 repo_action_modal, 
-                tabs
+                tabs,
+                repo_components["repo_explorer_input"]
             ],
             js="() => { setTimeout(() => { window.scrollTo({top: 0, behavior: 'smooth'}); window.dispatchEvent(new Event('repoExplorerNavigation')); }, 150); }"
         )