use serde_json::json;
use std::collections::HashSet;
use std::sync::{Arc, Mutex};
pub mod coverage;
pub mod enrich;
pub mod limits;
pub mod rank;
pub mod recall;
use crate::db::{
graph::{GraphDb, QueryExt as _, RepoQueryExt as _},
vector::{VectorDb, VectorSearchExt as _},
};
use crate::models::RepoScope;
use crate::pipeline::embed::Embedder;
use crate::startup_guard::RepoEmbedMarker as EmbedMarker;
pub use limits::{DEFAULT_MAX_RESULTS, MAX_RESULTS_CEILING, ResolvedLimit, resolve_max_results};
pub(crate) use recall::CHANNEL_FIELD;
#[derive(Clone)]
pub struct SearchContext<'a> {
pub vector_db: &'a Arc<VectorDb>,
pub graph_db: &'a Arc<GraphDb>,
pub embedder: &'a Arc<Mutex<Embedder>>,
}
pub struct SearchFilters<'a> {
pub kinds: Option<&'a str>,
pub path: Option<&'a str>,
}
pub async fn run_search_hybrid_context(
query: &str,
max_results: usize,
repo: &RepoScope,
filters: SearchFilters<'_>,
ctx: &SearchContext<'_>,
) -> anyhow::Result<serde_json::Value> {
let max_results = resolve_max_results(max_results).value;
let vector = ctx
.embedder
.lock()
.unwrap()
.embed_query(query)
.map_err(|e| anyhow::anyhow!("Embedding failed: {}", e))?;
let repo_names = repo.filter_names();
let mismatch_note = search_model_mismatch_note(&repo_names, ctx).await;
if let Some(note) = &mismatch_note {
tracing::warn!("search_hybrid_context: {note}");
}
let expanded_kinds = rank::parse_kinds(filters.kinds);
let normalized_path = recall::normalized_path(filters.path);
let pool_window = recall::pool_window(max_results, normalized_path.is_some());
let search_results = ctx
.vector_db
.search(&vector, pool_window, &repo_names, &expanded_kinds)
.await?;
let prefix_results = ctx
.graph_db
.find_entities_by_name_prefix(query, &repo_names, max_results)
.await
.unwrap_or_else(|_| json!([]));
let mut seen_uuids: HashSet<String> = HashSet::new();
let mut combined: Vec<serde_json::Value> = Vec::new();
let rejected_prefix_uuids = recall::merge_prefix_hits(
&prefix_results,
&expanded_kinds,
normalized_path.as_deref(),
&mut seen_uuids,
&mut combined,
);
let pool = recall::CandidatePool {
vector: &vector,
query,
search_results: &search_results,
seen_uuids: &mut seen_uuids,
repo_names: &repo_names,
expanded_kinds: &expanded_kinds,
candidate_limit: pool_window,
scored_prefix_uuids: &rejected_prefix_uuids,
ctx,
};
let mut vector_hits = pool.collect().await;
if let Some(pattern) = &normalized_path {
vector_hits.retain(|hit| {
rank::path_allows(
Some(pattern),
hit.get("file_path").and_then(|v| v.as_str()).unwrap_or(""),
)
});
}
combined.extend(rank::rerank(vector_hits, query));
recall::strip_internal_fields(&mut combined);
if combined.is_empty() {
return Ok(match mismatch_note {
Some(note) => json!({ "note": note }),
None => serde_json::Value::Null,
});
}
combined.truncate(max_results);
let uuids: Vec<String> = combined
.iter()
.map(|entity| {
entity
.get("uuid")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string()
})
.collect();
let fetched = ctx
.graph_db
.get_entities_with_dependencies(&uuids, &repo_names)
.await?;
let context = serde_json::Value::Array(rank::dedup_by_identity(
fetched.as_array().cloned().unwrap_or_default(),
));
let enriched_context = enrich::enrich_with_relationships(&context, ctx.graph_db, repo)
.await
.unwrap_or(context);
Ok(enriched_context)
}
async fn search_model_mismatch_note(
repo_names: &[String],
ctx: &SearchContext<'_>,
) -> Option<String> {
if repo_names.is_empty() {
return None;
}
let active_model = ctx.embedder.lock().unwrap().model_name();
let markers = ctx.graph_db.repo_embed_markers(repo_names).await.ok()?;
let mismatched: Vec<&EmbedMarker> = markers
.iter()
.filter(|m| {
m.embed_model
.as_deref()
.is_some_and(|their| their != active_model)
})
.collect();
if mismatched.is_empty() {
return None;
}
Some(format!(
"Repositories {} were indexed with embedding model '{}' \
but this query was searched with '{}': they will not surface \
in semantic search. Re-index them with '{}' \
(`knot-indexer --clean`).",
mismatched
.iter()
.map(|m| m.repo_name.clone())
.collect::<Vec<_>>()
.join(", "),
mismatched[0].embed_model.as_deref().unwrap_or("?"),
active_model,
active_model
))
}