Upload 15 files

app/solver.py

@@ -518,13 +518,28 @@ class QuizSolver:
         
         # 1. Command string extraction (e.g., "uv http get ...")
         if 'command string' in question_lower or 'craft the command' in question_lower:
-            # Look for command patterns
-            # Pattern: "uv http get ..." or similar command strings
+            # First, check error responses which often contain the exact command format
+            # Pattern: "Submit the command string: uv http get ..."
+            submit_command_pattern = r'[Ss]ubmit\s+the\s+command\s+string[:\s]+(uv\s+http\s+get\s+[^\n<>"]+(?:\s+-H\s+"[^"]+")?)'
+            match = re.search(submit_command_pattern, combined, re.IGNORECASE)
+            if match:
+                command = match.group(1).strip()
+                command = ' '.join(command.split())
+                # Substitute <your email> or <email> with actual email if provided
+                if email:
+                    command = command.replace('<your email>', email)
+                    command = command.replace('<email>', email)
+                logger.info(f"Extracted command from instruction: {command[:100]}...")
+                return command
+            
+            # Look for command patterns in the page
+            # Pattern: "uv http get https://..." - need to capture full URL and optional header
+            # More specific pattern that captures the full command
             command_patterns = [
-                r'(uv\s+http\s+get\s+[^\n<>"]+(?:\s+-H\s+"[^"]+")?)',  # uv http get with optional headers
+                r'(uv\s+http\s+get\s+https?://[^\s<>"]+(?:\?[^\s<>"]+)?(?:\s+-H\s+"[^"]+")?)',  # Full URL with query params and header
+                r'(uv\s+http\s+get\s+https?://[^\s<>"]+)',  # Just URL
                 r'(curl\s+[^\n<>"]+)',
                 r'(wget\s+[^\n<>"]+)',
-                r'(http\s+get\s+[^\n<>"]+)',
             ]
             for pattern in command_patterns:
                 match = re.search(pattern, combined, re.IGNORECASE)
@@ -534,29 +549,15 @@ class QuizSolver:
                     command = ' '.join(command.split())
                     # Stop at certain delimiters that indicate end of command
                     # Remove anything after common sentence endings that aren't part of command
-                    command = re.sub(r'\s+(?:Submit|Do not|Note|Remember|Important).*$', '', command, flags=re.IGNORECASE)
+                    command = re.sub(r'\s+(?:Submit|Do not|Note|Remember|Important|\.\s+[A-Z]).*$', '', command, flags=re.IGNORECASE)
                     # Substitute <your email> or <email> with actual email if provided
                     if email:
                         command = command.replace('<your email>', email)
                         command = command.replace('<email>', email)
-                        command = command.replace('your email', email)
-                    logger.info(f"Extracted command string: {command[:100]}...")
-                    return command
-            
-            # Also look for commands in error responses or instructions
-            # Pattern: "Submit the command string: ..."
-            submit_command_pattern = r'[Ss]ubmit\s+the\s+command\s+string[:\s]+(uv\s+http\s+get\s+[^\n<>"]+(?:\s+-H\s+"[^"]+")?)'
-            match = re.search(submit_command_pattern, combined, re.IGNORECASE)
-            if match:
-                command = match.group(1).strip()
-                command = ' '.join(command.split())
-                # Substitute <your email> or <email> with actual email if provided
-                if email:
-                    command = command.replace('<your email>', email)
-                    command = command.replace('<email>', email)
-                    command = command.replace('your email', email)
-                logger.info(f"Extracted command from instruction: {command[:100]}...")
-                return command
+                    # Ensure we have a complete command (should have URL)
+                    if 'http' in command.lower() and len(command) > 20:  # Reasonable minimum length
+                        logger.info(f"Extracted command string: {command[:100]}...")
+                        return command
         
         # 2. Exact path extraction (e.g., "/project2/data-preparation.md")
         if 'exact' in question_lower and ('path' in question_lower or 'string' in question_lower or 'link' in question_lower):
@@ -595,52 +596,60 @@ class QuizSolver:
         
         # 3. Git commands extraction (e.g., "git add ..." and "git commit ...")
         if 'git' in question_lower and ('command' in question_lower or 'stage' in question_lower or 'commit' in question_lower):
-            # Look for git commands
             git_commands = []
             
-            # Pattern for "git add ..." - be more specific
+            # First, check error responses which often contain the exact format
+            # Pattern: "Need git add ... then git commit ..."
+            need_pattern = r'[Nn]eed\s+(git\s+add\s+[^\s]+)\s+then\s+(git\s+commit\s+[^\n<>"]+)'
+            need_match = re.search(need_pattern, combined, re.IGNORECASE)
+            if need_match:
+                cmd1 = need_match.group(1).strip()
+                cmd2 = need_match.group(2).strip()
+                # Ensure cmd2 has the message in quotes if needed
+                if '-m' in cmd2 and '"' not in cmd2 and "'" not in cmd2:
+                    # Extract message and add quotes
+                    msg_match = re.search(r'-m\s+([^\s]+)', cmd2)
+                    if msg_match:
+                        msg = msg_match.group(1)
+                        cmd2 = cmd2.replace(msg, f'"{msg}"')
+                git_commands = [cmd1, cmd2]
+                result = '\n'.join(git_commands)
+                logger.info(f"Extracted git commands from error response: {result}")
+                return result
+            
+            # Look for git commands in the page
+            # Pattern for "git add env.sample"
             git_add_patterns = [
-                r'git\s+add\s+([^\s\n<>"]+)',  # "git add env.sample"
-                r'(git\s+add\s+[^\n<>"]+)',  # Full command
+                r'(git\s+add\s+env\.sample)',  # Specific file
+                r'(git\s+add\s+[^\s\n<>"]+)',  # General
             ]
             for pattern in git_add_patterns:
                 git_add_match = re.search(pattern, combined, re.IGNORECASE)
                 if git_add_match:
                     cmd = git_add_match.group(1).strip()
-                    # If it's just the file, prepend "git add "
-                    if not cmd.startswith('git'):
-                        cmd = f"git add {cmd}"
                     if cmd not in git_commands:
                         git_commands.append(cmd)
                     break
             
-            # Pattern for "git commit ..." - look for commit with message
+            # Pattern for "git commit -m "chore: keep env sample""
             git_commit_patterns = [
-                r'git\s+commit\s+-m\s+"([^"]+)"',  # "git commit -m "message""
-                r'git\s+commit\s+-m\s+([^\s\n<>"]+)',  # "git commit -m message"
-                r'(git\s+commit\s+[^\n<>"]+)',  # Full command
+                r'(git\s+commit\s+-m\s+"[^"]+")',  # With quotes
+                r'(git\s+commit\s+-m\s+[^\s\n<>"]+)',  # Without quotes (will add them)
             ]
             for pattern in git_commit_patterns:
                 git_commit_match = re.search(pattern, combined, re.IGNORECASE)
                 if git_commit_match:
                     cmd = git_commit_match.group(1).strip()
-                    # If it's just the message, construct full command
-                    if not cmd.startswith('git'):
-                        # Check if message is in quotes
-                        if '"' in cmd or "'" in cmd:
-                            cmd = f'git commit -m {cmd}'
-                        else:
-                            cmd = f'git commit -m "{cmd}"'
+                    # If message doesn't have quotes, add them
+                    if '-m' in cmd and '"' not in cmd and "'" not in cmd:
+                        msg_match = re.search(r'-m\s+([^\s]+)', cmd)
+                        if msg_match:
+                            msg = msg_match.group(1)
+                            cmd = cmd.replace(msg, f'"{msg}"')
                     if cmd not in git_commands:
                         git_commands.append(cmd)
                     break
             
-            # Also check error responses like "Need git add ... then git commit ..."
-            need_pattern = r'[Nn]eed\s+(git\s+add\s+[^\s]+)\s+then\s+(git\s+commit\s+[^\n<>"]+)'
-            need_match = re.search(need_pattern, combined, re.IGNORECASE)
-            if need_match:
-                git_commands = [need_match.group(1).strip(), need_match.group(2).strip()]
-            
             # If we found git commands, return them
             if git_commands:
                 # If question asks for "two commands", return them separated by newline
@@ -649,7 +658,7 @@ class QuizSolver:
                     logger.info(f"Extracted git commands: {result}")
                     return result
                 # Otherwise return the first one
-                else:
+                elif git_commands:
                     logger.info(f"Extracted git command: {git_commands[0]}")
                     return git_commands[0]
         

app/utils.py

@@ -74,19 +74,37 @@ def extract_submit_url(text: str, base_url: str) -> Optional[str]:
                 continue
     
     # Try to find relative submit links (e.g. href="/submit")
+    # Be more strict - only match actual submit endpoints, not paths that happen to contain "submit" in text
     rel_patterns = [
-        r'href=["\\\'](/[^"\\\']*submit[^"\\\']*)["\\\']',
-        r'(/[^\\s"<>\']*submit[^\\s"<>\']*)',
+        r'href=["\\\'](/[^"\\\']*submit[^"\\\']*)["\\\']',  # href="/submit" or href="/api/submit"
         r'POST\s+to\s+JSON\s+to\s+(/[^\s<>"\'\)]+)',  # "POST to JSON to /submit"
         r'[Pp]ost\s+(?:to|at):\s+(/[^\s<>"\'\)]+)',  # "POST to: /submit"
     ]
     for pattern in rel_patterns:
         matches = re.findall(pattern, text, re.IGNORECASE)
         if matches:
-            candidate = matches[0].strip().rstrip('.,;:!?)}]{["\'')
-            joined = urljoin(base_url, candidate)
-            logger.info(f"Found relative submit URL: {joined}")
-            return joined
+            candidate = matches[0].strip()
+            # Clean up - stop at first space, parenthesis, or other non-URL character
+            # This prevents matching text like "/path (description).Submit"
+            candidate = re.sub(r'[\s\(\)].*$', '', candidate)  # Remove everything after space or paren
+            candidate = candidate.rstrip('.,;:!?)}]{["\'')
+            # Validate it's actually a submit endpoint (contains "submit" in the path)
+            # AND it doesn't contain file extensions that indicate it's a document path
+            if 'submit' in candidate.lower() and not any(ext in candidate.lower() for ext in ['.md', '.txt', '.pdf', '.html']):
+                try:
+                    joined = urljoin(base_url, candidate)
+                    # Final validation - ensure it's a valid URL
+                    parsed = urlparse(joined)
+                    if parsed.scheme and parsed.netloc:
+                        logger.info(f"Found relative submit URL: {joined}")
+                        return joined
+                except Exception as e:
+                    logger.warning(f"Invalid relative URL candidate: {candidate}, error: {e}")
+                    continue
+    
+    # Don't match generic paths that happen to contain "submit" in surrounding text
+    # This was causing issues where paths like "/project2/data-preparation.md (local copy provided).Submit that exact"
+    # were being matched incorrectly
     
     # Try to find submit URL in the base domain with /submit path
     if base_url: