Upload 9 files

app/solver.py

@@ -918,17 +918,41 @@ def solve_project2_entry(text: str, email: str) -> str:
     return email
 
 def solve_project2_uv(text: str, email: str, page_content: Dict[str, Any]) -> str:
-    """Q2: /project2-uv - Return user-agent from JSON response"""
+    """Q2: /project2-uv - Return the command string (not the output)"""
     try:
-        url = f"https://tds-llm-analysis.s-anand.net/project2/uv.json?email={email}"
-        response = requests.get(url, headers={"Accept": "application/json"}, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        user_agent = data.get("user-agent", "")
-        logger.info(f"Extracted user-agent: {user_agent}")
-        return user_agent
+        # The question asks for the command string, not the user-agent value
+        # Construct the command: uv http get <url> -H "Accept: application/json"
+        from urllib.parse import urlencode, urlparse
+        
+        base_url = page_content.get('url', '')
+        # Extract the base domain from the current URL
+        if 'tds-llm-analysis.s-anand.net' in base_url:
+            domain = 'https://tds-llm-analysis.s-anand.net'
+        else:
+            # Fallback: construct from current URL
+            parsed = urlparse(base_url)
+            domain = f"{parsed.scheme}://{parsed.netloc}"
+        
+        # URL encode the email parameter
+        params = urlencode({'email': email})
+        api_url = f"{domain}/project2/uv.json?{params}"
+        
+        command = f'uv http get {api_url} -H "Accept: application/json"'
+        logger.info(f"Constructed command string: {command}")
+        return command
     except Exception as e:
         logger.error(f"Error in project2-uv: {e}")
+        # Fallback: try to extract from question text
+        if 'uv http get' in text.lower():
+            # Try to find the command in the text
+            import re
+            cmd_match = re.search(r'(uv\s+http\s+get\s+[^\n<>"]+(?:\s+-H\s+"[^"]+")?)', text, re.IGNORECASE)
+            if cmd_match:
+                cmd = cmd_match.group(1).strip()
+                # Replace email placeholder if present
+                if email and ('<your email>' in cmd or '<email>' in cmd):
+                    cmd = cmd.replace('<your email>', email).replace('<email>', email)
+                return cmd
         return ""
 
 def solve_project2_git(text: str, email: str) -> str:
@@ -1285,6 +1309,37 @@ class QuizSolver:
             
             # Ensure answer is in the correct format (string or simple JSON-serializable)
             answer = self._normalize_answer(answer)
+            
+            # Validate answer is not empty - try to extract from page if empty
+            if not answer or (isinstance(answer, str) and not answer.strip()):
+                logger.warning("Answer is empty, attempting to extract from page content")
+                # Try one more time to extract answer from page
+                text = page_content.get('all_text', page_content.get('text', ''))
+                if text:
+                    # Try to find any meaningful content
+                    simple_answer = self._extract_simple_answer(question_text, page_content)
+                    if simple_answer and simple_answer.strip():
+                        answer = simple_answer
+                        logger.info(f"Extracted answer from page: {answer[:100]}...")
+                    else:
+                        # Use LLM as last resort if we have time
+                        remaining = self._check_time_remaining()
+                        if remaining >= 10.0:
+                            try:
+                                available_data = self._extract_data_from_page(page_content)
+                                available_data['email'] = email
+                                llm_answer = await solve_with_llm(question_text, available_data)
+                                if llm_answer and llm_answer.strip():
+                                    answer = llm_answer.strip()
+                                    logger.info(f"LLM provided answer: {answer[:100]}...")
+                            except Exception as e:
+                                logger.warning(f"LLM retry failed: {e}")
+                
+                # Only use fallback if still empty
+                if not answer or (isinstance(answer, str) and not answer.strip()):
+                    logger.warning("Still empty after retry, using minimal fallback")
+                    answer = "answer"  # Fallback to prevent empty submission
+            
             logger.info(f"Answer computed: {str(answer)[:200]}...")
             
             # Store answer for final quiz
@@ -1757,14 +1812,15 @@ class QuizSolver:
                 logger.warning(f"Error handling GitHub API: {e}")
                 # Continue with other strategies
         
-        # Strategy 7: Use LLM to solve (only if we have enough time)
+        # Strategy 7: Use LLM to solve (be more aggressive - use it earlier)
         remaining = self._check_time_remaining()
         # For audio passphrase questions, use LLM even with less time
         is_audio_question = 'transcribe' in question.lower() or 'passphrase' in question.lower() or 'spoken phrase' in question.lower()
-        min_time_needed = 15.0 if is_audio_question else 25.0  # Lower threshold for audio questions
+        # Lower thresholds to use LLM more often
+        min_time_needed = 10.0 if is_audio_question else 15.0  # Reduced from 15/25 to 10/15
         
-        # Only use LLM if we have enough time AND haven't found answer yet
-        # Reserve at least 10s for submission
+        # Use LLM if we have enough time AND haven't found answer yet
+        # Reserve at least 5s for submission (reduced from 10s)
         if remaining >= min_time_needed:
             logger.info("Attempting to solve with LLM...")
             try:
@@ -1800,8 +1856,57 @@ class QuizSolver:
                 logger.info("Extracted simple answer from question")
                 return simple_answer
         
-        # Strategy 9: Last resort - return a default answer
-        logger.warning("Could not solve question, using default answer")
+        # Strategy 9: Final LLM attempt - use LLM even with limited time if we haven't found an answer
+        remaining = self._check_time_remaining()
+        if remaining >= 10.0:  # Try LLM if we have at least 10 seconds
+            logger.info("Final attempt: Using LLM to solve question")
+            try:
+                llm_answer = await solve_with_llm(question, available_data)
+                if llm_answer and llm_answer.strip():
+                    # Try to parse as JSON if it looks like JSON
+                    json_answer = extract_json_from_text(llm_answer)
+                    if json_answer:
+                        return json_answer
+                    # Clean up the answer
+                    llm_answer = llm_answer.strip()
+                    if len(llm_answer) > 0:
+                        logger.info("LLM provided answer in final attempt")
+                        return llm_answer
+            except Exception as e:
+                logger.warning(f"Final LLM attempt failed: {e}")
+        
+        # Strategy 10: Extract any meaningful text from page as last resort
+        text = page_content.get('all_text', page_content.get('text', ''))
+        # Try to find any substantial content that might be the answer
+        if text:
+            # Look for any quoted strings, numbers, or substantial text
+            # Extract first substantial sentence or phrase
+            sentences = re.split(r'[.!?]\s+', text)
+            for sentence in sentences:
+                sentence = sentence.strip()
+                # Skip if it's too short, too long, or looks like instructions
+                if 5 <= len(sentence) <= 200:
+                    # Skip common instruction phrases
+                    if not any(phrase in sentence.lower() for phrase in [
+                        'submit', 'answer', 'question', 'click', 'enter', 'provide',
+                        'please', 'note:', 'important', 'remember'
+                    ]):
+                        logger.info(f"Extracted potential answer from page text: {sentence[:100]}...")
+                        return sentence
+        
+        # Last resort: Try to extract any URL, email, or code from the page
+        url_match = re.search(r'https?://[^\s<>"\'\)]+', text)
+        if url_match:
+            logger.info(f"Extracted URL as answer: {url_match.group(0)}")
+            return url_match.group(0)
+        
+        email_match = re.search(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
+        if email_match:
+            logger.info(f"Extracted email as answer: {email_match.group(0)}")
+            return email_match.group(0)
+        
+        # Only use fallback if absolutely nothing found
+        logger.warning("Could not solve question after all strategies, using minimal fallback")
         return "answer"
     
     async def _extract_secret_from_scrape_task(self, question: str, page_content: Dict[str, Any]) -> Optional[str]:
@@ -2398,6 +2503,9 @@ class QuizSolver:
             # If it's very long, truncate
             if len(answer) > 1000:
                 answer = answer[:1000]
+            # Ensure we don't return empty string
+            if not answer:
+                return "answer"  # Fallback
             return answer
         
         # For other types, convert to string