second-brain-api 0.13.5

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
use second_brain_core::sqlite_store::SqliteStore;
use second_brain_core::store::StoreAdmin;

const MAX_NEAR_NAMES: usize = 5;

/// The refusal for a project filter no live memory is filed under, or None
/// when the project is stored.
pub(super) fn refuse_unknown_project(
    sqlite: &SqliteStore,
    project: &str,
) -> anyhow::Result<Option<String>> {
    if sqlite.scoped_count(None, None, Some(project))? > 0 {
        return Ok(None);
    }
    let stored = sqlite.distinct_project_paths()?;
    Ok(Some(unknown_project_message(project, &stored)))
}

/// The answer to a recall that names a project nothing is stored under.
fn unknown_project_message(name: &str, stored: &[(String, u64)]) -> String {
    let near = near_names(name, stored);
    if near.is_empty() {
        format!(
            "project \"{name}\" matches no stored project, and no stored project name is close; list_projects shows them all"
        )
    } else {
        format!(
            "project \"{name}\" matches no stored project; near names: {}",
            near.join(", ")
        )
    }
}

/// Stored slugs close to `name`, closest first. Slugs encode a whole path
/// (`/srv/garden` is `-srv-garden`), so a name is compared with
/// every tail of a slug that starts after a `-`, and a slug containing the
/// name counts as an exact match.
fn near_names(name: &str, stored: &[(String, u64)]) -> Vec<String> {
    let key = encode(name);
    if key.is_empty() {
        return Vec::new();
    }
    let allowed = (key.chars().count() / 3).max(1);
    let mut near: Vec<(usize, u64, &str)> = stored
        .iter()
        .filter_map(|(slug, count)| {
            let lowered = slug.to_ascii_lowercase();
            let distance = if key.len() >= 3 && lowered.contains(&key) {
                0
            } else {
                tails(&lowered)
                    .map(|tail| levenshtein(&key, tail))
                    .min()
                    .unwrap_or(usize::MAX)
            };
            (distance <= allowed).then_some((distance, *count, slug.as_str()))
        })
        .collect();
    near.sort_by(|a, b| a.0.cmp(&b.0).then(b.1.cmp(&a.1)).then(a.2.cmp(b.2)));
    near.into_iter()
        .take(MAX_NEAR_NAMES)
        .map(|(_, _, slug)| slug.to_string())
        .collect()
}

fn encode(name: &str) -> String {
    name.trim()
        .chars()
        .map(|c| {
            if c.is_ascii_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '-'
            }
        })
        .collect::<String>()
        .trim_matches('-')
        .to_string()
}

fn tails(slug: &str) -> impl Iterator<Item = &str> {
    std::iter::once(slug).chain(
        slug.match_indices('-')
            .map(move |(i, _)| &slug[i + 1..])
            .filter(|tail| !tail.is_empty()),
    )
}

fn levenshtein(a: &str, b: &str) -> usize {
    let b: Vec<char> = b.chars().collect();
    let mut row: Vec<usize> = (0..=b.len()).collect();
    for (i, ca) in a.chars().enumerate() {
        let mut previous = row[0];
        row[0] = i + 1;
        for (j, cb) in b.iter().enumerate() {
            let substituted = previous + usize::from(ca != *cb);
            previous = row[j + 1];
            row[j + 1] = substituted.min(row[j] + 1).min(row[j + 1] + 1);
        }
    }
    row[b.len()]
}

#[cfg(test)]
mod tests {
    use super::*;

    fn stored(slugs: &[(&str, u64)]) -> Vec<(String, u64)> {
        slugs.iter().map(|(s, c)| (s.to_string(), *c)).collect()
    }

    #[test]
    fn a_typo_of_the_last_path_component_is_near() {
        let stored = stored(&[("-srv-garden", 40), ("-srv-orchard", 30), ("-srv-notes", 5)]);
        assert_eq!(near_names("gardn", &stored), vec!["-srv-garden"]);
        assert_eq!(near_names("orhcard", &stored), vec!["-srv-orchard"]);
    }

    #[test]
    fn a_slug_containing_the_name_ranks_before_a_typo_and_ties_go_to_the_bigger_project() {
        let stored = stored(&[
            ("-srv-my-orchard", 3),
            ("-srv-orchard", 30),
            ("-srv-orcharx", 50),
        ]);
        assert_eq!(
            near_names("orchard", &stored),
            vec!["-srv-orchard", "-srv-my-orchard", "-srv-orcharx"]
        );
    }

    #[test]
    fn an_unrelated_name_has_no_near_names() {
        let stored = stored(&[("-srv-garden", 40), ("-srv-orchard", 30)]);
        assert!(near_names("kubernetes", &stored).is_empty());
        assert!(near_names("  ", &stored).is_empty());
    }

    #[test]
    fn at_most_five_near_names_are_listed() {
        let slugs: Vec<(String, u64)> = (0..8).map(|i| (format!("-p{i}-app"), i)).collect();
        assert_eq!(near_names("app", &slugs).len(), 5);
    }

    #[test]
    fn the_message_lists_near_names_or_points_at_list_projects() {
        let stored = stored(&[("-srv-garden", 40)]);
        assert_eq!(
            unknown_project_message("gardn", &stored),
            "project \"gardn\" matches no stored project; near names: -srv-garden"
        );
        let none = unknown_project_message("kubernetes", &stored);
        assert!(none.contains("no stored project name is close"), "{none}");
        assert!(none.contains("list_projects"), "{none}");
    }

    #[test]
    fn levenshtein_counts_single_edits() {
        assert_eq!(levenshtein("kitten", "sitting"), 3);
        assert_eq!(levenshtein("", "abc"), 3);
        assert_eq!(levenshtein("same", "same"), 0);
    }
}