fix(query-analyzer): pick strongest dateparser match, not the leftmost (#2768) (#2772)

dateparser.search_dates over-matches: short common words that are weekday
or month abbreviations in some language ("we"/"me"/"did" resolve to a
weekday, "do" to Sunday) come back as bogus dates. The analyzer took the
first valid match, so when a false positive appeared before the real date
the query got a plausible-but-wrong temporal window — worse than none,
since the constraint is non-null and nothing downstream can tell that
extraction failed.

The previous defence was a hard-coded blacklist of such words, which is a
moving target (every short word dateparser resolves is a new instance of
the same bug) and was already partly dead code: the `len(text) > 3` escape
hatch re-admitted every multi-character entry, so only the <=3-char words
did any work. The bug also depends on the dateparser version — 1.4.1 (the
version shipped in the published image) added "we" as an English Wednesday
abbreviation that survives `languages=["en"]` scoping, while the locked
1.2.2 does not — so language scoping is not a stable fix either.

Replace the blacklist + leftmost selection with a signal score: each match
is scored by the date content it actually carries (a digit is strongest,
then explicit month/relative words, then weekday/period words). Matches
with no signal (bare abbreviations) score zero and are rejected; among the
rest the strongest wins, ties broken by longest span. This subsumes the
entire blacklist and is independent of language and dateparser version.

Tested (Friday reference date, where these abbreviations resolve):
- "what did we discuss"                   -> no constraint (was 07-12/07-15)
- "tell me what we decided on 2026-06-10" -> 2026-06-10 (was 07-15)
- "what did we discuss in May"            -> May (unchanged, now robust)

Regression tests assert analyzer output, never raw dateparser spans, so
they hold across dateparser versions.

Co-authored-by: Nicolò Boschi <boschi1997@gmail.com>

Author: benfrank241

hindsight-api-slim/hindsight_api/engine/query_analyzer.py

@@ -6,6 +6,7 @@
 """
 
 import logging
+import re
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
 
@@ -19,6 +20,103 @@
 
 logger = logging.getLogger(__name__)
 
+# dateparser.search_dates over-matches: short common words that happen to be
+# weekday/month abbreviations in *some* language ("we"/"me"/"did" -> a weekday,
+# "do" -> Sunday) come back as bogus dates. When such a false positive appears
+# *before* the real date in the query, taking the first match (or a hard-coded
+# blacklist of such words) silently produces a wrong temporal window — worse
+# than none, because the constraint is non-null so nothing downstream can tell
+# extraction failed. See issue #2768.
+#
+# Instead of blacklisting words one at a time (a moving target — every short
+# word dateparser resolves is a new instance of the same bug), we score each
+# match by the date signal it actually carries and keep only matches with a
+# real signal, preferring the strongest. A bare weekday abbreviation carries no
+# day/month/year and scores zero, so it is rejected regardless of language or
+# dateparser version.
+_TOKEN_RE = re.compile(r"[a-z0-9]+")
+_MONTH_WORDS = {
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+}
+_RELATIVE_WORDS = {"today", "yesterday", "tomorrow", "tonight", "now"}
+_WEEKDAY_WORDS = {
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+}
+_PERIOD_WORDS = {
+    "last",
+    "next",
+    "this",
+    "past",
+    "coming",
+    "ago",
+    "week",
+    "weeks",
+    "month",
+    "months",
+    "year",
+    "years",
+    "day",
+    "days",
+    "hour",
+    "hours",
+    "minute",
+    "minutes",
+    "quarter",
+    "decade",
+    "century",
+    "weekend",
+    "morning",
+    "afternoon",
+    "evening",
+    "night",
+    "noon",
+    "midnight",
+}
+
+
+def _date_match_score(text: str) -> int:
+    """Score how strong a temporal signal a matched span carries.
+
+    A score of 0 means the span is a bare token with no explicit date content
+    (the false-positive class from issue #2768) and should be rejected. Higher
+    scores mean a stronger, less ambiguous date reference. A digit is the
+    strongest signal (day/year/ISO date); an explicit English month/relative
+    word next; weekday names and period words weakest but still explicit.
+    """
+    tokens = _TOKEN_RE.findall(text.lower())
+    if not tokens:
+        return 0
+    score = 0
+    if any(any(ch.isdigit() for ch in tok) for tok in tokens):
+        score += 100
+    token_set = set(tokens)
+    if token_set & _MONTH_WORDS:
+        score += 50
+    if token_set & _RELATIVE_WORDS:
+        score += 50
+    if token_set & _WEEKDAY_WORDS:
+        score += 30
+    if token_set & _PERIOD_WORDS:
+        score += 20
+    return score
+
 
 class TemporalConstraint(BaseModel):
     """
@@ -164,20 +262,23 @@ def analyze(self, query: str, reference_date: datetime | None = None) -> QueryAn
         if not results:
             return QueryAnalysis(temporal_constraint=None)
 
-        # Filter out false positives (common words parsed as dates)
-        false_positives = {"do", "may", "march", "will", "can", "sat", "sun", "mon", "tue", "wed", "thu", "fri"}
-        valid_results = [
-            (text, date)
+        # Score each match by the date signal it carries and keep only those
+        # with a real signal, rejecting bare weekday/month-abbreviation false
+        # positives ("we"/"me"/"did"). Prefer the strongest match, breaking ties
+        # by longest span, so an explicit date ("in May", "2026-06-10") always
+        # beats an earlier weak word regardless of position. See issue #2768.
+        scored_results = [
+            (_date_match_score(text), len(text), date)
             for text, date in results
-            if (text.lower() not in false_positives or len(text) > 3)
-            and not is_embedded_cjk_dateparser_match(query, text)
+            if not is_embedded_cjk_dateparser_match(query, text)
         ]
+        scored_results = [entry for entry in scored_results if entry[0] > 0]
 
-        if not valid_results:
+        if not scored_results:
             return QueryAnalysis(temporal_constraint=None)
 
-        # Use the first valid date found
-        _, parsed_date = valid_results[0]
+        # Highest signal score wins; ties broken by the longest matched span.
+        _, _, parsed_date = max(scored_results, key=lambda entry: (entry[0], entry[1]))
 
         # Create constraint for single day
         start_date = parsed_date.replace(hour=0, minute=0, second=0, microsecond=0)

hindsight-api-slim/tests/test_query_analyzer.py

@@ -827,6 +827,86 @@ def boom(*args, **kwargs):
     assert any("dateparser" in rec.message for rec in caplog.records), "Should log a warning when dateparser fails"
 
 
+# ---------------------------------------------------------------------------
+# Regression tests for issue #2768: query_analyzer must pick the strongest
+# dateparser match, not the leftmost one, and reject bare weekday/month
+# abbreviations ("we"/"me"/"did") that carry no real date signal.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "text",
+    ["we", "me", "did", "do", "wed", "sat", "will", "can"],
+)
+def test_date_match_score_rejects_bare_false_positives(text):
+    """Bare words that dateparser resolves to weekday abbreviations carry no
+    real date signal and must score zero (so they are rejected)."""
+    from hindsight_api.engine.query_analyzer import _date_match_score
+
+    assert _date_match_score(text) == 0
+
+
+@pytest.mark.parametrize(
+    "text",
+    ["in May", "March 2024", "2026-06-10", "yesterday", "last week", "on Wednesday"],
+)
+def test_date_match_score_keeps_real_signals(text):
+    """Spans carrying an explicit date signal (digit, month, relative word,
+    weekday name, period word) must score above zero."""
+    from hindsight_api.engine.query_analyzer import _date_match_score
+
+    assert _date_match_score(text) > 0
+
+
+def test_date_match_score_prefers_digit_over_weak_word():
+    """An explicit date (digit) must outscore a weekday/month word so ranking
+    picks it even when it appears later in the query."""
+    from hindsight_api.engine.query_analyzer import _date_match_score
+
+    assert _date_match_score("2026-06-10") > _date_match_score("on Wednesday")
+
+
+def test_query_analyzer_rejects_bare_word_false_positive(query_analyzer):
+    """#2768 rejection: a query whose only dateparser match is a bare word
+    ("we"/"did" depending on version) must yield no temporal constraint rather
+    than a plausible-but-wrong date. Reference date is a Friday, which is when
+    these weekday abbreviations resolve."""
+    reference_date = datetime(2026, 7, 17, 12, 0, 0)  # Friday
+
+    analysis = query_analyzer.analyze("what did we discuss", reference_date)
+
+    assert analysis.temporal_constraint is None, (
+        "A bare false-positive word must not produce a temporal constraint"
+    )
+
+
+def test_query_analyzer_prefers_explicit_date_over_leading_weak_word(query_analyzer):
+    """#2768 ranking: an explicit date must win over an earlier weak word
+    ("me"/"we") regardless of position in the query."""
+    reference_date = datetime(2026, 7, 17, 12, 0, 0)  # Friday
+
+    analysis = query_analyzer.analyze(
+        "tell me what we decided on 2026-06-10", reference_date
+    )
+
+    assert analysis.temporal_constraint is not None, "Should extract the explicit date"
+    assert analysis.temporal_constraint.start_date.year == 2026
+    assert analysis.temporal_constraint.start_date.month == 6
+    assert analysis.temporal_constraint.start_date.day == 10
+
+
+def test_query_analyzer_keeps_real_month_with_leading_weak_word(query_analyzer):
+    """#2768: the real month must survive even when a weak word precedes it in
+    the query."""
+    reference_date = datetime(2026, 7, 17, 12, 0, 0)  # Friday
+
+    analysis = query_analyzer.analyze("what did we discuss in May", reference_date)
+
+    assert analysis.temporal_constraint is not None, "Should extract the real month"
+    assert analysis.temporal_constraint.start_date.year == 2026
+    assert analysis.temporal_constraint.start_date.month == 5
+
+
 @pytest.mark.parametrize(
     ("query", "expected"),
     [