feat(search): add fuzzy search and "did you mean?" suggestions

QaidVoid · QaidVoid · commit 934b0ffe6f90 · 2026-04-01T20:48:35.000+05:45
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -43,6 +43,7 @@ libsqlite3-sys = { version = ">=0.30.1,<0.36.0", features = [ "bundled" ]}
 miette = { version = "7.6.0", features = ["fancy"] }
 minisign-verify = "0.2.4"
 nix = { version = "0.30.1", features = ["fs", "ioctl", "term", "user"] }
+nucleo-matcher = "0.3.1"
 nu-ansi-term = "0.50.3"
 once_cell = "1.21"
 percent-encoding = "2.3.2"
diff --git a/crates/soar-cli/src/inspect.rs b/crates/soar-cli/src/inspect.rs
@@ -11,6 +11,7 @@ use soar_db::repository::{
     metadata::MetadataRepository,
 };
 use soar_dl::http_client::SHARED_AGENT;
+use soar_operations::search;
 use soar_utils::bytes::format_bytes;
 use tracing::{error, info};
 use ureq::http::header::CONTENT_LENGTH;
@@ -115,6 +116,11 @@ pub async fn inspect_log(package: &str, inspect_type: InspectType) -> SoarResult
 
     if packages.is_empty() {
         error!("Package {} not found", package);
+        if let Ok(suggestions) = search::suggest_similar(&ctx, package, 3).await {
+            if !suggestions.is_empty() {
+                info!("Did you mean: {}?", suggestions.join(", "));
+            }
+        }
     } else {
         let selected_pkg = if packages.len() > 1 {
             &select_package_interactively(packages, &query.name.unwrap_or(package.to_string()))?
diff --git a/crates/soar-cli/src/install.rs b/crates/soar-cli/src/install.rs
@@ -1,6 +1,6 @@
 use nu_ansi_term::Color::{Blue, Cyan, Green, Magenta, Red, Yellow};
 use soar_core::{package::install::InstallTarget, SoarResult};
-use soar_operations::{install, InstallOptions, InstallReport, ResolveResult, SoarContext};
+use soar_operations::{install, search, InstallOptions, InstallReport, ResolveResult, SoarContext};
 use tabled::{
     builder::Builder,
     settings::{themes::BorderCorrection, Panel, Style},
@@ -89,6 +89,11 @@ pub async fn install_packages(
             }
             ResolveResult::NotFound(name) => {
                 error!("Package {} not found", name);
+                if let Ok(suggestions) = search::suggest_similar(ctx, &name, 3).await {
+                    if !suggestions.is_empty() {
+                        info!("Did you mean: {}?", suggestions.join(", "));
+                    }
+                }
             }
             ResolveResult::AlreadyInstalled {
                 pkg_name,
@@ -177,6 +182,11 @@ async fn install_with_show(
                     }
                     ResolveResult::NotFound(name) => {
                         error!("Package {} not found", name);
+                        if let Ok(suggestions) = search::suggest_similar(ctx, &name, 3).await {
+                            if !suggestions.is_empty() {
+                                info!("Did you mean: {}?", suggestions.join(", "));
+                            }
+                        }
                     }
                     ResolveResult::AlreadyInstalled {
                         pkg_name,
@@ -250,7 +260,13 @@ async fn install_with_show(
         };
 
         if repo_pkgs.is_empty() {
-            error!("Package {} not found", query.name.as_ref().unwrap());
+            let name = query.name.as_ref().unwrap();
+            error!("Package {} not found", name);
+            if let Ok(suggestions) = search::suggest_similar(ctx, name, 3).await {
+                if !suggestions.is_empty() {
+                    info!("Did you mean: {}?", suggestions.join(", "));
+                }
+            }
             continue;
         }
 
diff --git a/crates/soar-db/src/models/metadata.rs b/crates/soar-db/src/models/metadata.rs
@@ -137,6 +137,18 @@ pub struct PackageListing {
     pub version: String,
 }
 
+/// Minimal package data for fuzzy search candidate matching.
+/// Only fetches fields needed for matching, avoiding expensive JSON deserialization.
+#[derive(Debug, Clone, Queryable, Selectable)]
+#[diesel(table_name = packages)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct FuzzyCandidate {
+    pub id: i32,
+    pub pkg_name: String,
+    pub pkg_id: String,
+    pub description: Option<String>,
+}
+
 /// Package with repository name attached.
 /// This is used when querying across multiple repositories.
 #[derive(Debug, Clone)]
diff --git a/crates/soar-db/src/repository/metadata.rs b/crates/soar-db/src/repository/metadata.rs
@@ -15,8 +15,8 @@ use super::core::SortDirection;
 use crate::{
     models::{
         metadata::{
-            Maintainer, NewMaintainer, NewPackage, NewPackageMaintainer, NewRepository, Package,
-            PackageListing,
+            FuzzyCandidate, Maintainer, NewMaintainer, NewPackage, NewPackageMaintainer,
+            NewRepository, Package, PackageListing,
         },
         types::PackageProvide,
     },
@@ -61,6 +61,26 @@ impl MetadataRepository {
         result
     }
 
+    /// Loads lightweight package data for fuzzy matching.
+    /// Returns only (id, pkg_name, pkg_id, description) to minimize memory and deserialization.
+    pub fn load_fuzzy_candidates(conn: &mut SqliteConnection) -> QueryResult<Vec<FuzzyCandidate>> {
+        trace!("loading fuzzy candidates");
+        packages::table
+            .select(FuzzyCandidate::as_select())
+            .load(conn)
+    }
+
+    /// Fetches full package details for a set of package IDs.
+    pub fn find_by_ids(conn: &mut SqliteConnection, ids: &[i32]) -> QueryResult<Vec<Package>> {
+        if ids.is_empty() {
+            return Ok(Vec::new());
+        }
+        packages::table
+            .filter(packages::id.eq_any(ids))
+            .select(Package::as_select())
+            .load(conn)
+    }
+
     /// Lists packages with pagination and sorting using Diesel DSL.
     pub fn list_paginated(
         conn: &mut SqliteConnection,
diff --git a/crates/soar-operations/Cargo.toml b/crates/soar-operations/Cargo.toml
@@ -12,6 +12,7 @@ categories.workspace = true
 [dependencies]
 fast-glob = { workspace = true }
 minisign-verify = { workspace = true }
+nucleo-matcher = { workspace = true }
 once_cell = { workspace = true }
 rayon = { workspace = true }
 soar-config = { workspace = true }
diff --git a/crates/soar-operations/src/search.rs b/crates/soar-operations/src/search.rs
@@ -1,17 +1,26 @@
 use std::collections::HashMap;
 
+use nucleo_matcher::{
+    pattern::{CaseMatching, Normalization, Pattern},
+    Config, Matcher, Utf32String,
+};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use soar_config::config::get_config;
 use soar_core::{database::models::Package, package::query::PackageQuery, SoarResult};
-use soar_db::repository::{
-    core::{CoreRepository, SortDirection},
-    metadata::MetadataRepository,
+use soar_db::{
+    models::metadata::FuzzyCandidate,
+    repository::{
+        core::{CoreRepository, SortDirection},
+        metadata::MetadataRepository,
+    },
 };
 use tracing::{debug, trace};
 
 use crate::{SearchEntry, SearchResult, SoarContext};
 
 /// Search for packages across all repositories.
+///
+/// Uses fuzzy matching by default. Falls back to SQL LIKE for case-sensitive searches.
 pub async fn search_packages(
     ctx: &SoarContext,
     query: &str,
@@ -24,27 +33,27 @@ pub async fn search_packages(
         limit = ?limit,
         "searching packages"
     );
+
     let metadata_mgr = ctx.metadata_manager().await?;
     let diesel_db = ctx.diesel_core_db()?;
+    let search_limit = limit.or(get_config().search_limit).unwrap_or(20);
 
-    let search_limit = limit.or(get_config().search_limit).unwrap_or(20) as i64;
-    trace!(search_limit = search_limit, "using search limit");
-
-    let packages: Vec<Package> = metadata_mgr.query_all_flat(|repo_name, conn| {
-        let pkgs = if case_sensitive {
-            MetadataRepository::search_case_sensitive(conn, query, Some(search_limit))?
-        } else {
-            MetadataRepository::search(conn, query, Some(search_limit))?
-        };
-        Ok(pkgs
-            .into_iter()
-            .map(|p| {
-                let mut pkg: Package = p.into();
-                pkg.repo_name = repo_name.to_string();
-                pkg
-            })
-            .collect())
-    })?;
+    let packages: Vec<Package> = if case_sensitive {
+        let sql_limit = search_limit as i64;
+        metadata_mgr.query_all_flat(|repo_name, conn| {
+            let pkgs = MetadataRepository::search_case_sensitive(conn, query, Some(sql_limit))?;
+            Ok(pkgs
+                .into_iter()
+                .map(|p| {
+                    let mut pkg: Package = p.into();
+                    pkg.repo_name = repo_name.to_string();
+                    pkg
+                })
+                .collect())
+        })?
+    } else {
+        fuzzy_search(ctx, query, search_limit).await?
+    };
 
     let installed_pkgs: HashMap<(String, String, String), bool> = diesel_db
         .with_conn(|conn| {
@@ -58,15 +67,14 @@ pub async fn search_packages(
 
     let entries: Vec<SearchEntry> = packages
         .into_iter()
-        .take(search_limit as usize)
+        .take(search_limit)
         .map(|package| {
             let key = (
                 package.repo_name.clone(),
                 package.pkg_id.clone(),
                 package.pkg_name.clone(),
             );
             let installed = installed_pkgs.get(&key).copied().unwrap_or(false);
-
             SearchEntry {
                 package,
                 installed,
@@ -80,6 +88,111 @@ pub async fn search_packages(
     })
 }
 
+/// Returns top fuzzy-matched packages across all repositories.
+async fn fuzzy_search(ctx: &SoarContext, query: &str, limit: usize) -> SoarResult<Vec<Package>> {
+    let metadata_mgr = ctx.metadata_manager().await?;
+
+    let candidates: Vec<(String, FuzzyCandidate)> =
+        metadata_mgr.query_all_flat(|repo_name, conn| {
+            let items = MetadataRepository::load_fuzzy_candidates(conn)?;
+            Ok(items
+                .into_iter()
+                .map(|c| (repo_name.to_string(), c))
+                .collect())
+        })?;
+
+    let scored = score_candidates(query, &candidates);
+    let top: Vec<_> = scored.into_iter().take(limit).collect();
+
+    let mut repo_ids: HashMap<&str, Vec<i32>> = HashMap::new();
+    for &(_, idx) in &top {
+        let (repo_name, candidate) = &candidates[idx];
+        repo_ids
+            .entry(repo_name.as_str())
+            .or_default()
+            .push(candidate.id);
+    }
+
+    let mut full_packages: HashMap<(String, i32), Package> = HashMap::new();
+    for (repo_name, ids) in &repo_ids {
+        if let Some(pkgs) =
+            metadata_mgr.query_repo(repo_name, |conn| MetadataRepository::find_by_ids(conn, ids))?
+        {
+            for p in pkgs {
+                let db_id = p.id;
+                let mut pkg: Package = p.into();
+                pkg.repo_name = repo_name.to_string();
+                full_packages.insert((repo_name.to_string(), db_id), pkg);
+            }
+        }
+    }
+
+    let packages: Vec<Package> = top
+        .into_iter()
+        .filter_map(|(_, idx)| {
+            let (repo_name, candidate) = &candidates[idx];
+            full_packages.remove(&(repo_name.clone(), candidate.id))
+        })
+        .collect();
+
+    Ok(packages)
+}
+
+/// Suggest similar package names for "did you mean?" messages.
+pub async fn suggest_similar(
+    ctx: &SoarContext,
+    query: &str,
+    max: usize,
+) -> SoarResult<Vec<String>> {
+    let metadata_mgr = ctx.metadata_manager().await?;
+
+    let candidates: Vec<(String, FuzzyCandidate)> =
+        metadata_mgr.query_all_flat(|repo_name, conn| {
+            let items = MetadataRepository::load_fuzzy_candidates(conn)?;
+            Ok(items
+                .into_iter()
+                .map(|c| (repo_name.to_string(), c))
+                .collect())
+        })?;
+
+    let scored = score_candidates(query, &candidates);
+
+    let suggestions: Vec<String> = scored
+        .into_iter()
+        .take(max)
+        .map(|(_, idx)| {
+            let (_, candidate) = &candidates[idx];
+            candidate.pkg_name.clone()
+        })
+        .collect();
+
+    Ok(suggestions)
+}
+
+fn score_candidates(query: &str, candidates: &[(String, FuzzyCandidate)]) -> Vec<(u32, usize)> {
+    let mut matcher = Matcher::new(Config::DEFAULT);
+    let pattern = Pattern::parse(query, CaseMatching::Ignore, Normalization::Smart);
+
+    let mut scored: Vec<(u32, usize)> = Vec::new();
+
+    for (idx, (_repo_name, candidate)) in candidates.iter().enumerate() {
+        let name_buf = Utf32String::from(candidate.pkg_name.as_str());
+        let name_score = pattern.score(name_buf.slice(..), &mut matcher);
+
+        let id_buf = Utf32String::from(candidate.pkg_id.as_str());
+        let id_score = pattern.score(id_buf.slice(..), &mut matcher);
+
+        let best_score = [name_score, id_score].into_iter().flatten().max();
+
+        if let Some(score) = best_score {
+            scored.push((score, idx));
+        }
+    }
+
+    scored.sort_by(|a, b| b.0.cmp(&a.0));
+    scored
+}
+
 /// Query detailed package information.
 ///
 /// Accepts query strings in the format `name#pkg_id@version:repo`.
