Method gather_candidates

atomic-cli/src/commands/vault/context.rs:192–254

Gather candidate memory nodes from all seeds. Returns a map of memory node id -> accumulated candidate score. With no seeds at all, falls back to the most recently updated memories so a bare `atomic vault context` is still useful.

(
        &self,
        repo: &Repository,
        limit: usize,
    )

    /// With no seeds at all, falls back to the most recently updated
    /// memories so a bare `atomic vault context` is still useful.
    fn gather_candidates(
        &self,
        repo: &Repository,
        limit: usize,
    ) -> CliResult<HashMap<String, CandidateScore>> {
        let mut candidates: HashMap<String, CandidateScore> = HashMap::new();
        let mut seed_terms: Vec<String> = self.query.clone();

        if let Some(intent_id) = &self.intent {
            self.seed_from_intent(repo, intent_id, &mut seed_terms, &mut candidates)?;
        }

        for file in &self.files {
            let node_id = format!("file:{}", file.trim_start_matches("./"));
            add_memory_neighbors(repo, &node_id, 1, &mut candidates)?;
        }

        let seed_query = seed_terms.join(" ");
        if !seed_query.trim().is_empty() {
            let pool = limit.saturating_mul(SEARCH_POOL_MULTIPLIER);
            let nodes = repo
                .vault_kg_search_by_kind(&seed_query, pool, "memory")
                .map_err(CliError::Repository)?;
            for (rank, node) in nodes.iter().enumerate() {
                let base = rank_score(rank);
                merge_candidate(
                    &mut candidates,
                    &node.id,
                    memory_path_from_node(node),
                    base,
                    false,
                );
            }
            self.scan_memory_bodies(repo, &seed_query, &mut candidates)?;
        }

        // No seeds of any kind: fall back to the most recent memories.
        if candidates.is_empty() && !self.has_explicit_seeds() {
            let mut metas = repo
                .vault_list("memory/", Some(VaultEntryType::Memory))
                .map_err(CliError::Repository)?;
            metas.sort_by(|a, b| b.updated_at.cmp(&a.updated_at));
            for meta in metas {
                let Some(entry) = repo
                    .vault_retrieve(&meta.path)
                    .map_err(CliError::Repository)?
                else {
                    continue;
                };
                if !is_eligible_memory(&entry) {
                    continue;
                }
                if let Some(node_id) = memory_path_to_node_id(&meta.path) {
                    merge_candidate(&mut candidates, &node_id, Some(meta.path), 0.0, false);
                }
                if candidates.len() >= limit {
                    break;
                }