fix: keep command palette search results relevant for short queries

Fixes #345

Author: PierreRaybaut

datalab/gui/commandpalette.py

@@ -43,13 +43,20 @@ def fuzzy_score(query: str, text: str) -> int | None:
     consecutive matches and matches at word boundaries are rewarded, while
     gaps between matched characters are penalised.
 
+    A plain subsequence match is too permissive on its own: a short query
+    like "rota" would match unrelated commands such as "impoRt annOTAtions".
+    To cull that noise, a match is only accepted when its matched characters
+    form a single contiguous run (a plain substring, e.g. "rota" in "Rotate")
+    or when every run of matched characters starts at a word boundary
+    (acronym / word-initials style, e.g. "fan" in "Fourier ANalysis").
+
     Args:
         query: Lowercased, trimmed search query.
         text: Lowercased haystack to match against.
 
     Returns:
-        A score (higher is better) when ``query`` is a subsequence of
-        ``text``, otherwise ``None``.
+        A score (higher is better) when ``query`` matches ``text`` under the
+        rule above, otherwise ``None``.
     """
     if not query:
         return 0
@@ -58,19 +65,36 @@ def fuzzy_score(query: str, text: str) -> int | None:
     score = 0
     text_index = 0
     prev = -2
+    # A "run" is a maximal block of contiguous matched characters. We track
+    # how many runs the match spans and how many start at a word boundary,
+    # to reject scattered mid-word noise afterwards.
+    runs = 0
+    boundary_runs = 0
     for char in query:
         found = text.find(char, text_index)
         if found == -1:
             return None
+        contiguous = found == prev + 1
+        at_boundary = found == 0 or text[found - 1] in _BOUNDARY_CHARS
         score += 1
-        if found == prev + 1:
+        if contiguous:
             score += 5
-        if found == 0 or text[found - 1] in _BOUNDARY_CHARS:
+        if at_boundary:
             score += 3
         if prev >= 0:
             score -= min(found - prev - 1, 3)
+        if not contiguous:
+            runs += 1
+            if at_boundary:
+                boundary_runs += 1
         prev = found
         text_index = found + 1
+    # Cull scattered noise: keep the match only when the query occurs as a
+    # plain substring (a single contiguous run — the greedy scan above can miss
+    # it, e.g. "fft" in "… Fourier … fft") or when every run of matched
+    # characters starts at a word boundary (acronym / word-initials style).
+    if boundary_runs != runs and query not in text:
+        return None
     return score
 
 

datalab/tests/backbone/commandpalette_unit_test.py

@@ -29,17 +29,25 @@ def test_fuzzy_score():
     """Test the fuzzy subsequence matcher."""
     # Empty query matches anything with a neutral score
     assert fuzzy_score("", "anything") == 0
-    # Contiguous and non-contiguous subsequences match
+    # A plain substring (single contiguous run) matches, even mid-word
     assert fuzzy_score("fft", "processing › fourier analysis › fft") is not None
+    assert fuzzy_score("rota", "rotate") is not None
+    assert fuzzy_score("bration", "calibration") is not None
+    # Acronym-style matches where every run starts at a word boundary match
     assert fuzzy_score("fan", "fourier analysis") is not None
     # A missing character or an over-long query does not match
     assert fuzzy_score("xyz", "fourier analysis") is None
     assert fuzzy_score("abcdef", "abc") is None
-    # A contiguous match scores higher than a scattered one
+    # Scattered mid-word noise is rejected: "rota" must not match paths that
+    # merely contain r, o, t, a as scattered mid-word runs
+    assert fuzzy_score("rota", "edit › annotations › import annotations") is None
+    assert fuzzy_score("rota", "analysis › horizontal projection") is None
+    assert fuzzy_score("abc", "a1b2c3 def") is None
+    # A contiguous match scores higher than a boundary-run one
     contiguous = fuzzy_score("abc", "abc def")
-    scattered = fuzzy_score("abc", "a1b2c3 def")
-    assert contiguous is not None and scattered is not None
-    assert contiguous > scattered
+    boundary = fuzzy_score("abc", "a b c")
+    assert contiguous is not None and boundary is not None
+    assert contiguous > boundary
 
 
 def test_collect_commands():