Method find_entry_points

src/context/builder.rs:178–294

Searches for entry-point nodes matching the query and extracted symbols. Pipeline: 1. FTS search on the full query, each extracted symbol, stem variants, and agent-provided extra keywords. 2. Exact name supplement — ensures perfect name matches are never buried by BM25 noise. 3. Re-rank with structural signals (kind, visibility, path). 4. Connectivity boost (incoming call counts). 5. Co-occurrenc

(
        &self,
        query: &str,
        symbols: &[String],
        options: &BuildContextOptions,
    )

    /// 6. Per-file diversity cap — limits how many symbols from a single file
    ///    appear so one large file doesn't dominate the output.
    async fn find_entry_points(
        &self,
        query: &str,
        symbols: &[String],
        options: &BuildContextOptions,
    ) -> Result<Vec<Node>> {
        debug_assert!(
            !query.is_empty(),
            "find_entry_points called with empty query"
        );
        debug_assert!(options.search_limit > 0, "search_limit must be positive");
        let mut seen_ids: HashSet<String> = options.exclude_node_ids.clone();
        let mut candidates: Vec<SearchResult> = Vec::new();
        let cap = options.max_nodes * 2;

        // Build a deduplicated, ordered list of FTS terms. Earlier revisions
        // searched the full query, every extracted symbol, every stem, and
        // every extra keyword separately — but these sets overlap heavily
        // (e.g. `symbol` "foo" and `keyword` "foo" produce identical FTS
        // results). libsql serializes queries on a single connection, so each
        // duplicate term costs a full roundtrip. Order matters for the
        // `cap`-based early exit, so we keep the original priority:
        //   full query → symbols → stems → extra keywords.
        let mut fts_terms: Vec<String> = Vec::new();
        let mut fts_seen: HashSet<String> = HashSet::new();
        let push_term = |t: String, terms: &mut Vec<String>, seen: &mut HashSet<String>| {
            if !t.is_empty() && seen.insert(t.clone()) {
                terms.push(t);
            }
        };
        push_term(query.to_string(), &mut fts_terms, &mut fts_seen);
        for s in symbols {
            push_term(s.clone(), &mut fts_terms, &mut fts_seen);
        }
        let stems = generate_stem_variants(symbols);
        for s in &stems {
            push_term(s.clone(), &mut fts_terms, &mut fts_seen);
        }
        for k in &options.extra_keywords {
            push_term(k.clone(), &mut fts_terms, &mut fts_seen);
        }

        for term in &fts_terms {
            if candidates.len() >= cap {
                break;
            }
            let results = self.db.search_nodes(term, options.search_limit).await?;
            for sr in results {
                if Self::score_passes(sr.score, options.min_score)
                    && seen_ids.insert(sr.node.id.clone())
                {
                    candidates.push(sr);
                }
            }
        }

        // --- Exact name supplement ---
        // Ensures perfect name matches aren't buried by BM25 noise.