fix: quoted search falls back to BM25 and returns unrelated files (#527) (#528)

* fix: skip filename matching and BM25 ranking for quoted exact queries (#527)

Quoted queries like '"cleanupScopeMappings"' set exact:true on individual
AST terms but not the global exact flag. Two code paths only checked the
global flag, causing filename matching to tokenize the query into subwords
("cleanup", "scope", "map") and BM25 ranking to boost unrelated files.

Now check both the global exact flag and is_exact_search(ast) to properly
detect quoted queries.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: resolve flaky test_tree_cache_invalidation by removing exact size assertion

The test asserted get_cache_size() == 1, but the tree cache is a
process-wide global static. Other tests running in parallel can add
entries even though this test holds a local mutex. Replaced with
is_in_cache() check which validates the correct behavior without
being sensitive to parallel test interference.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: buger

src/language/tree_cache_tests.rs

@@ -151,8 +151,9 @@ fn test_tree_cache_invalidation() {
     // But the content is different, so the byte positions should differ
     assert_ne!(tree1.root_node().end_byte(), tree2.root_node().end_byte());
 
-    // Check that the cache still has one entry (the updated one)
-    assert_eq!(tree_cache::get_cache_size(), 1);
+    // Check that the file is still in the cache (updated entry)
+    // Note: we don't check exact cache size because other tests running in parallel
+    // may add entries to the global cache even though this test holds the local mutex.
     assert!(tree_cache::is_in_cache("test_file2.rs"));
 }
 

src/search/query.rs

@@ -271,7 +271,7 @@ fn update_ast_exact(expr: &mut elastic_query::Expr) {
 }
 
 /// Helper function to check if the AST represents an exact search
-fn is_exact_search(expr: &elastic_query::Expr) -> bool {
+pub fn is_exact_search(expr: &elastic_query::Expr) -> bool {
     match expr {
         elastic_query::Expr::Term { exact, .. } => *exact,
         elastic_query::Expr::And(left, right) => is_exact_search(left) && is_exact_search(right),

src/search/search_runner.rs

@@ -508,8 +508,12 @@ pub fn perform_probe(options: &SearchOptions) -> Result<LimitedSearchResults> {
     let mut all_files = file_term_map.keys().cloned().collect::<HashSet<_>>();
 
     // Add filename matches if enabled
+    // Skip filename matching for exact searches (--exact flag) and when all AST terms
+    // are exact (e.g., quoted queries like "cleanupScopeMappings"). Filename matching
+    // tokenizes terms into subwords which creates false positives for exact queries. (#527)
     let fm_start = Instant::now();
-    if include_filenames && !exact {
+    let ast_all_exact = crate::search::query::is_exact_search(&plan.ast);
+    if include_filenames && !exact && !ast_all_exact {
         if debug_mode {
             println!("DEBUG: Starting filename matching...");
         }
@@ -1352,17 +1356,18 @@ pub fn perform_probe(options: &SearchOptions) -> Result<LimitedSearchResults> {
             format_duration(remaining_time)
         );
     }
-    // Rank results (skip if exact flag is set)
+    // Rank results (skip if exact flag is set or all AST terms are exact like quoted queries)
     let rr_start = Instant::now();
+    let skip_ranking = *exact || ast_all_exact;
     if debug_mode {
-        if *exact {
+        if skip_ranking {
             println!("DEBUG: Skipping result ranking due to exact flag being set");
         } else {
             println!("DEBUG: Starting result ranking...");
         }
     }
 
-    if !*exact {
+    if !skip_ranking {
         // Only perform ranking if exact flag is not set
         rank_search_results(&mut final_results, queries, reranker, *question);
 

tests/integration_tests.rs

@@ -853,3 +853,115 @@ fn test_skipped_files_with_match_counts() {
         "Total results + skipped should be at least 2"
     );
 }
+
+/// Issue #527: Quoted search on a directory should behave like exact/literal search.
+/// Previously, quoted queries like '"cleanupScopeMappings"' ran filename matching
+/// and BM25 ranking with tokenized subwords, causing unrelated files containing
+/// "cleanup", "scope", or "map" individually to appear in results.
+#[test]
+fn test_quoted_search_excludes_unrelated_files() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+
+    // File that DOES contain the exact camelCase symbol
+    let src_dir = temp_dir.path().join("model");
+    fs::create_dir(&src_dir).expect("Failed to create model dir");
+    let mut target_file = File::create(src_dir.join("products.go")).unwrap();
+    target_file
+        .write_all(
+            b"package products\n\n\
+              func cleanupScopeMappings(tx interface{}, newApis []string, oldApis []string) error {\n\
+              \treturn nil\n\
+              }\n",
+        )
+        .unwrap();
+
+    // File that does NOT contain the symbol but has subwords: cleanup, scope, mapping
+    let app_dir = temp_dir.path().join("app");
+    fs::create_dir(&app_dir).expect("Failed to create app dir");
+    let mut unrelated_file = File::create(app_dir.join("about.go")).unwrap();
+    unrelated_file
+        .write_all(
+            b"package about\n\n\
+              // GetVersion returns the cleanup version info for scope mappings\n\
+              func GetVersion() string {\n\
+              \treturn \"1.0.0\"\n\
+              }\n\n\
+              // GetStatus returns the status of the scope cleanup mapping service\n\
+              func GetStatus() string {\n\
+              \treturn \"running\"\n\
+              }\n",
+        )
+        .unwrap();
+
+    // Another unrelated file with no matching subwords at all
+    let mut other_file = File::create(app_dir.join("users.go")).unwrap();
+    other_file
+        .write_all(
+            b"package users\n\n\
+              func GetUser(id string) (interface{}, error) {\n\
+              \treturn nil, nil\n\
+              }\n",
+        )
+        .unwrap();
+
+    let custom_ignores: Vec<String> = vec![];
+
+    // Quoted query — should only return products.go
+    let queries = vec!["\"cleanupScopeMappings\"".to_string()];
+    let options = SearchOptions {
+        path: temp_dir.path(),
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: None,
+        max_bytes: None,
+        max_tokens: None,
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: None,
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false, // NOT using --exact flag, just quoted query
+        no_gitignore: true,
+        lsp: false,
+    };
+
+    let search_result = perform_probe(&options).expect("Search should succeed");
+
+    println!(
+        "Quoted search returned {} results:",
+        search_result.results.len()
+    );
+    for r in &search_result.results {
+        println!("  File: {} Lines: {:?}", r.file, r.lines);
+    }
+
+    // All results should be from products.go (the file containing the exact symbol)
+    assert!(
+        !search_result.results.is_empty(),
+        "Quoted search should find at least one result"
+    );
+    for r in &search_result.results {
+        assert!(
+            r.file.contains("products.go"),
+            "Quoted search should only return files containing the exact symbol, got: {}",
+            r.file
+        );
+    }
+
+    // Specifically: about.go should NOT appear (it only has subwords, not the full symbol)
+    let has_about = search_result
+        .results
+        .iter()
+        .any(|r| r.file.contains("about.go"));
+    assert!(
+        !has_about,
+        "about.go should not appear in quoted search results — it doesn't contain 'cleanupScopeMappings'"
+    );
+}