Fix citation formatting bugs

- Fix greedy regex that captured entire paragraphs instead of just case names
- Fix party name abbreviations to not abbreviate state names (North Carolina stays North Carolina)
- Fix edition parsing to preserve ordinal suffix (6th ed. not 6 ed.)
- Add validation to reject malformed case names containing ISSUE, ANALYSIS, etc.
- Fix false article detection - case names like "Moody v. NetChoice" no longer trigger article lookups
- Skip geographic terms in party abbreviations per Bluebook rules

Author: claude

backend/app/services/bluebook_rules.py

@@ -33,16 +33,30 @@ def format_citation(self, citation: Citation, is_law_review: bool = True) -> str
     def format_case(self, citation: Citation, is_law_review: bool = True) -> str:
         """
         Format case citation per Bluebook Rule 10.
-        
+
         Law review format: Case Name, Vol. Reporter Page, Pincite (Court Year).
         Brief format: Case Name, Vol. Reporter Page, Pincite (Court Year)
         """
         if not citation.parties or len(citation.parties) < 2:
             return citation.raw_text
-        
+
+        # Validate party names are reasonable (not paragraphs of text)
+        plaintiff_raw = citation.parties[0]
+        defendant_raw = citation.parties[1]
+
+        # Party names shouldn't be too long or contain invalid words
+        invalid_indicators = ["ISSUE", "ANALYSIS", "See ", "The Court", "Whether"]
+        for indicator in invalid_indicators:
+            if indicator in plaintiff_raw or indicator in defendant_raw:
+                return citation.raw_text
+
+        # Party names should be reasonable length (under 50 chars typically)
+        if len(plaintiff_raw) > 60 or len(defendant_raw) > 60:
+            return citation.raw_text
+
         # Format case name (Rule 10.2)
-        plaintiff = abbreviate_party_name(citation.parties[0])
-        defendant = abbreviate_party_name(citation.parties[1])
+        plaintiff = abbreviate_party_name(plaintiff_raw)
+        defendant = abbreviate_party_name(defendant_raw)
         case_name = f"{plaintiff} v. {defendant}"
 
         # Build reporter citation (Rule 10.3)

backend/app/services/lookup_service.py

@@ -561,13 +561,20 @@ async def smart_complete(self, citation: Citation) -> Dict[str, Any]:
         if citation.raw_text:
             raw_text = citation.raw_text.strip()
 
-            # Check if it looks like a case
-            if " v. " in raw_text or " v " in raw_text:
-                case_result = await self.search_by_text(raw_text, "case")
+            # Check if it looks like a case name (contains "v." pattern)
+            # This is the primary indicator - don't search for articles about cases
+            case_name_pattern = re.search(r'([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*)\s+v\.?\s+([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*)', raw_text)
+            if case_name_pattern:
+                # Extract just the case name for search
+                case_name = case_name_pattern.group(0)
+                case_result = await self.search_by_text(case_name, "case")
                 results["strategies_tried"].append("case_text_search")
                 if case_result.get("found"):
                     case_result["inferred_type"] = "case"
                     return case_result
+                # Don't fall through to article search for case names
+                results["note"] = f"Looks like case citation: {case_name}"
+                return results
 
             # Check if it looks like a statute
             if re.search(r'\b(U\.?S\.?C|C\.?F\.?R|Code|§)', raw_text, re.IGNORECASE):
@@ -577,18 +584,21 @@ async def smart_complete(self, citation: Citation) -> Dict[str, Any]:
                     statute_result["inferred_type"] = "statute"
                     return statute_result
 
-            # Try as article
-            article_result = await self.search_by_text(raw_text, "article")
-            results["strategies_tried"].append("article_text_search")
-            if article_result.get("found"):
-                article_result["inferred_type"] = "law_review"
-                return article_result
-
-            # Last resort: generic case search
-            case_result = await self.search_by_text(raw_text, "case")
-            results["strategies_tried"].append("fallback_case_search")
-            if case_result.get("found"):
-                return case_result
+            # Only try article search if it doesn't look like a case
+            # and has some indication it's an article (author name pattern, journal words)
+            if re.search(r'(Law Review|L\. Rev\.|Journal|L\.J\.|\d+\s+[A-Z][a-z]+\.\s+L\.)', raw_text):
+                article_result = await self.search_by_text(raw_text, "article")
+                results["strategies_tried"].append("article_text_search")
+                if article_result.get("found"):
+                    article_result["inferred_type"] = "law_review"
+                    return article_result
+
+            # Last resort: generic case search (but only if text is short enough to be a citation)
+            if len(raw_text) < 200:
+                case_result = await self.search_by_text(raw_text, "case")
+                results["strategies_tried"].append("fallback_case_search")
+                if case_result.get("found"):
+                    return case_result
 
         return results
 

backend/app/utils/bluebook_patterns.py

@@ -9,16 +9,20 @@
 # Citation detection patterns
 PATTERNS: Dict[str, Pattern] = {
     # Cases: Party v. Party, Volume Reporter Page (Court Year)
+    # Fixed to not be greedy with whitespace - party names can't span multiple lines
     "case_complete": re.compile(
-        r"([A-Z][a-zA-Z\.\'\-\s]+)\s+v\.\s+([A-Z][a-zA-Z\.\'\-\s]+),\s*"
-        r"(\d+)\s+([A-Z][a-zA-Z\.\s\d]+)\s+(\d+)"
+        r"([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*(?:,?\s+(?:LLC|Inc\.|Corp\.|Co\.|Ltd\.))?)\s+v\.\s+"
+        r"([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*(?:,?\s+(?:LLC|Inc\.|Corp\.|Co\.|Ltd\.))?),\s*"
+        r"(\d+)\s+([A-Z][a-zA-Z\.\s\d]+?)\s+(\d+)"
         r"(?:,\s*(\d+(?:-\d+)?))?\s*"
         r"\(([^)]+)\)"
     ),
-    
+
     # Incomplete case: just Party v. Party (missing reporter info)
+    # Fixed to not be greedy - requires capitalized words only
     "case_incomplete": re.compile(
-        r"([A-Z][a-zA-Z\.\'\-\s]+)\s+v\.\s+([A-Z][a-zA-Z\.\'\-\s]+)"
+        r"([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*)\s+v\.\s+"
+        r"([A-Z][a-zA-Z\.\'\-]+(?:\s+[A-Z][a-zA-Z\.\'\-]+)*)"
         r"(?!\s*,\s*\d+\s+[A-Z])"
     ),
 
@@ -48,10 +52,11 @@
     ),
 
     # Books: Author, Title (Edition Year)
+    # Fixed to capture full edition like "6th" not just "6"
     "book": re.compile(
         r"([A-Z][a-zA-Z\.\s]+),\s+"
         r"([A-Z][^(]+)\s*"
-        r"\((?:(\d+)(?:st|nd|rd|th)\s+ed\.\s+)?(\d{4})\)"
+        r"\((?:(\d+(?:st|nd|rd|th))\s+ed\.\s+)?(\d{4})\)"
     ),
 
     # Short forms - Id.
@@ -452,18 +457,46 @@ def get_journal_abbreviation(journal: str) -> str:
     """Get the Bluebook abbreviation for a journal."""
     return JOURNAL_ABBREVIATIONS.get(journal, journal)
 
-def abbreviate_party_name(party: str) -> str:
-    """Abbreviate a party name per Bluebook Table 6."""
+def abbreviate_party_name(party: str, is_state_party: bool = False) -> str:
+    """
+    Abbreviate a party name per Bluebook Table 6.
+
+    Args:
+        party: The party name to abbreviate
+        is_state_party: If True, don't abbreviate state/geographic names
+                       (per Rule 10.2.1 - states as parties keep full names)
+    """
     result = party
-    
+
     # Remove "The" at beginning (Rule 10.2.1(e))
     if result.lower().startswith("the "):
         result = result[4:]
-    
-    # Apply abbreviations
+
+    # Don't abbreviate if it's a state/geographic entity as a party
+    # (e.g., "North Carolina" as defendant should stay "North Carolina")
+    if is_state_party:
+        return result.strip()
+
+    # Check if this is a pure state name - if so, don't abbreviate
+    if result.strip() in STATE_ABBREVIATIONS:
+        return result.strip()
+
+    # Words that should NOT be abbreviated in party names
+    # (only abbreviate organizational/business terms)
+    skip_abbreviations = {
+        "North", "South", "East", "West", "Eastern", "Western",
+        "Northern", "Southern", "Northeast", "Northwest",
+        "Southeast", "Southwest", "Carolina", "Dakota", "Virginia",
+        "Hampshire", "Jersey", "Mexico", "York"
+    }
+
+    # Apply abbreviations only for business/organizational terms
     for full, abbrev in PARTY_ABBREVIATIONS.items():
+        # Skip geographic terms in case names
+        if full in skip_abbreviations:
+            continue
         # Use word boundaries for replacement
         pattern = re.compile(r'\b' + re.escape(full) + r'\b', re.IGNORECASE)
         result = pattern.sub(abbrev, result)
-    
+
     return result.strip()