#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QueryType {
NaturalLanguage,
Identifier,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct QueryParams {
pub rrf_k: f64,
pub vector_candidate_multiplier: usize,
pub bm25_weight: f64,
pub vector_weight: f64,
}
const IDENTIFIER_PARAMS: QueryParams = QueryParams {
rrf_k: 60.0,
vector_candidate_multiplier: 3,
bm25_weight: 2.5,
vector_weight: 1.0,
};
const NL_PARAMS: QueryParams = QueryParams {
rrf_k: 60.0,
vector_candidate_multiplier: 5,
bm25_weight: 1.0,
vector_weight: 1.0,
};
pub fn classify_query(query: &str) -> QueryType {
let trimmed = query.trim();
if trimmed.is_empty() {
return QueryType::Identifier;
}
let normalized = trimmed.trim_end_matches('.');
let words: Vec<&str> = normalized.split_whitespace().collect();
if words.len() == 1 {
return QueryType::Identifier;
}
if normalized.contains("::") || normalized.contains("->") || normalized.contains('.') {
return QueryType::Identifier;
}
let identifier_word_count = words.iter().filter(|w| is_compound_identifier(w)).count();
if identifier_word_count > words.len() / 2 {
return QueryType::Identifier;
}
if has_nl_indicators(normalized, &words) {
return QueryType::NaturalLanguage;
}
if words.len() >= 3 {
return QueryType::NaturalLanguage;
}
QueryType::Identifier
}
pub fn params_for_query_type(query_type: QueryType) -> QueryParams {
match query_type {
QueryType::NaturalLanguage => NL_PARAMS,
QueryType::Identifier => IDENTIFIER_PARAMS,
}
}
fn is_compound_identifier(token: &str) -> bool {
if token.contains('_') {
return true;
}
if token.contains("::") || token.contains('.') || token.contains('/') || token.contains('\\') {
return true;
}
let chars: Vec<char> = token.chars().collect();
for i in 1..chars.len() {
if chars[i].is_uppercase() && chars[i - 1].is_lowercase() {
return true;
}
}
false
}
fn has_nl_indicators(query: &str, words: &[&str]) -> bool {
let lower = query.to_lowercase();
let question_prefixes = [
"how ", "what ", "where ", "why ", "when ", "which ", "who ", "does ", "do ", "is ",
"are ", "can ", "could ", "should ", "find ", "show ", "list ", "get ",
];
for prefix in &question_prefixes {
if lower.starts_with(prefix) {
return true;
}
}
if query.ends_with('?') {
return true;
}
let nl_words = [
"the",
"a",
"an",
"of",
"in",
"for",
"to",
"with",
"from",
"that",
"this",
"all",
"each",
"every",
"about",
"between",
"through",
"during",
"before",
"after",
"into",
"using",
"where",
"when",
"how",
"what",
"which",
"does",
"handle",
"implement",
"return",
"returns",
];
let lower_words: Vec<String> = words.iter().map(|w| w.to_lowercase()).collect();
let nl_count = lower_words
.iter()
.filter(|w| nl_words.contains(&w.as_str()))
.count();
nl_count >= 2 || (words.len() >= 3 && nl_count * 3 >= words.len())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_camel_case_as_identifier() {
assert_eq!(classify_query("parseConfig"), QueryType::Identifier);
assert_eq!(classify_query("handleError"), QueryType::Identifier);
assert_eq!(classify_query("getUserById"), QueryType::Identifier);
}
#[test]
fn classify_pascal_case_as_identifier() {
assert_eq!(classify_query("SearchWorker"), QueryType::Identifier);
assert_eq!(classify_query("HttpClient"), QueryType::Identifier);
assert_eq!(classify_query("DatabaseConnection"), QueryType::Identifier);
}
#[test]
fn classify_snake_case_as_identifier() {
assert_eq!(classify_query("parse_config"), QueryType::Identifier);
assert_eq!(classify_query("get_user_by_id"), QueryType::Identifier);
assert_eq!(classify_query("MAX_RETRIES"), QueryType::Identifier);
}
#[test]
fn classify_scope_path_as_identifier() {
assert_eq!(classify_query("std::io::Error"), QueryType::Identifier);
assert_eq!(
classify_query("crate::retrieval::hybrid"),
QueryType::Identifier
);
assert_eq!(
classify_query("config.retrieval.rrf_k"),
QueryType::Identifier
);
}
#[test]
fn classify_sentence_ending_period_as_natural_language() {
assert_eq!(
classify_query("how does auth work."),
QueryType::NaturalLanguage
);
}
#[test]
fn classify_dotted_identifiers_and_paths_as_identifier() {
assert_eq!(classify_query("foo.bar"), QueryType::Identifier);
assert_eq!(classify_query("src/main.rs"), QueryType::Identifier);
assert_eq!(classify_query("module::symbol"), QueryType::Identifier);
assert_eq!(classify_query("vera_core::config"), QueryType::Identifier);
}
#[test]
fn classify_nl_questions_as_natural_language() {
assert_eq!(
classify_query("how are errors handled"),
QueryType::NaturalLanguage
);
assert_eq!(
classify_query("what does this function return"),
QueryType::NaturalLanguage
);
assert_eq!(
classify_query("where is the database connection configured"),
QueryType::NaturalLanguage
);
}
#[test]
fn classify_nl_phrases_as_natural_language() {
assert_eq!(
classify_query("find all error handling code"),
QueryType::NaturalLanguage
);
assert_eq!(
classify_query("show the authentication logic"),
QueryType::NaturalLanguage
);
assert_eq!(
classify_query("code that handles user input validation"),
QueryType::NaturalLanguage
);
}
#[test]
fn classify_question_mark_as_natural_language() {
assert_eq!(
classify_query("what does authenticate do?"),
QueryType::NaturalLanguage
);
}
#[test]
fn classify_single_plain_word_as_identifier() {
assert_eq!(classify_query("authenticate"), QueryType::Identifier);
assert_eq!(classify_query("config"), QueryType::Identifier);
assert_eq!(classify_query("error"), QueryType::Identifier);
}
#[test]
fn classify_empty_query_as_identifier() {
assert_eq!(classify_query(""), QueryType::Identifier);
assert_eq!(classify_query(" "), QueryType::Identifier);
}
#[test]
fn classify_two_word_identifier_like() {
assert_eq!(classify_query("parse_config struct"), QueryType::Identifier);
}
#[test]
fn classify_mixed_nl_with_identifier() {
assert_eq!(
classify_query("how does parse_config work"),
QueryType::NaturalLanguage
);
}
#[test]
fn nl_params_share_identifier_rrf_k() {
let nl = params_for_query_type(QueryType::NaturalLanguage);
let id = params_for_query_type(QueryType::Identifier);
assert_eq!(
nl.rrf_k, id.rrf_k,
"NL and identifier should share RRF k: {} vs {}",
nl.rrf_k, id.rrf_k
);
assert_eq!(nl.rrf_k, 60.0);
assert_eq!(id.rrf_k, 60.0);
}
#[test]
fn nl_params_have_higher_vector_multiplier() {
let nl = params_for_query_type(QueryType::NaturalLanguage);
let id = params_for_query_type(QueryType::Identifier);
assert!(
nl.vector_candidate_multiplier > id.vector_candidate_multiplier,
"NL should fetch more vector candidates: {} > {}",
nl.vector_candidate_multiplier,
id.vector_candidate_multiplier
);
}
#[test]
fn identifier_params_preserve_defaults() {
let id = params_for_query_type(QueryType::Identifier);
assert_eq!(id.rrf_k, 60.0);
assert_eq!(id.vector_candidate_multiplier, 3);
}
#[test]
fn compound_identifier_detection() {
assert!(is_compound_identifier("parseConfig"));
assert!(is_compound_identifier("SearchWorker"));
assert!(is_compound_identifier("parse_config"));
assert!(is_compound_identifier("MAX_RETRIES"));
assert!(is_compound_identifier("std::io"));
assert!(is_compound_identifier("path/to/file"));
assert!(!is_compound_identifier("error"));
assert!(!is_compound_identifier("config"));
assert!(!is_compound_identifier("the"));
}
#[test]
fn nl_indicators_detected() {
assert!(has_nl_indicators(
"how are errors handled",
&["how", "are", "errors", "handled"]
));
assert!(has_nl_indicators(
"find the config",
&["find", "the", "config"]
));
assert!(!has_nl_indicators(
"parseConfig struct",
&["parseConfig", "struct"]
));
}
}