earl 0.5.2

AI-safe CLI for AI agents
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use anyhow::Result;

use crate::config::Config;
use crate::secrets::SecretManager;
use crate::template::catalog::TemplateCatalog;

use super::index::{SearchHit, build_documents};
use super::remote_openai_compat::search_remote;

pub async fn search_templates(
    query: &str,
    catalog: &TemplateCatalog,
    config: &Config,
    secrets: &SecretManager,
    limit: usize,
) -> Result<Vec<SearchHit>> {
    let documents = build_documents(catalog);

    if let Some(remote_hits) =
        search_remote(query, &documents, &config.search.remote, secrets).await?
    {
        return Ok(remote_hits.into_iter().take(limit).collect());
    }

    #[cfg(feature = "local-search")]
    {
        use super::local_fastembed::search_local;

        let query_owned = query.to_string();
        let docs_owned = documents.clone();
        let search_cfg = config.search.clone();

        let local_result = tokio::task::spawn_blocking(move || {
            search_local(&query_owned, &docs_owned, &search_cfg)
        })
        .await;

        if let Ok(Ok(hits)) = local_result {
            let mut hits = hits;
            hits.truncate(limit);
            return Ok(hits);
        }
    }

    let mut hits = lexical_fallback(query, &documents);
    hits.truncate(limit);
    Ok(hits)
}

fn lexical_fallback(query: &str, documents: &[super::index::SearchDocument]) -> Vec<SearchHit> {
    let mut hits: Vec<SearchHit> = documents
        .iter()
        .map(|doc| {
            let score = lexical_score(query, &doc.text);
            SearchHit {
                key: doc.key.clone(),
                score,
                summary: doc.summary.clone(),
            }
        })
        .collect();
    hits.sort_by(|a, b| b.score.total_cmp(&a.score));
    hits
}

fn lexical_score(query: &str, text: &str) -> f32 {
    let query_lower = query.to_ascii_lowercase();
    let text_lower = text.to_ascii_lowercase();
    let mut score = 0.0;
    for token in query_lower.split_whitespace() {
        if text_lower.contains(token) {
            score += 1.0;
        }
    }
    score
}