aicx 0.10.0

Context search and retrieval for AI-agent session history — find relevant past events, recover user intent, identify unfinished deliverables, and spot claims never backed by results
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use anyhow::Result;
use rmcp_memex::{
    search::BM25Index,
    storage::{ChromaDocument, StorageManager},
};
use std::path::{Path, PathBuf};
use std::sync::Arc;

use crate::progress::{FailureLog, NoopReporter, Phase, Reporter, recovery_hint_for};

use super::documents::build_steer_docs;
use super::metadata::write_steer_metadata;
use super::paths::{STEER_NAMESPACE, steer_bm25_config, steer_db_path};

async fn sync_steer_bm25_at(base: &Path, docs: &[ChromaDocument]) -> Result<()> {
    if docs.is_empty() {
        return Ok(());
    }

    let bm25 = BM25Index::new(&steer_bm25_config(base, false))?;
    let ids: Vec<String> = docs.iter().map(|doc| doc.id.clone()).collect();
    let _ = bm25.delete_documents(&ids).await;

    let bm25_docs: Vec<(String, String, String)> = docs
        .iter()
        .map(|doc| {
            (
                doc.id.clone(),
                STEER_NAMESPACE.to_string(),
                doc.document.clone(),
            )
        })
        .collect();
    bm25.add_documents(&bm25_docs).await?;

    Ok(())
}

pub(super) async fn sync_steer_index_at(base: &Path, new_files: &[&PathBuf]) -> Result<()> {
    let reporter: Arc<dyn Reporter> = Arc::new(NoopReporter);
    let failures = FailureLog::new();
    sync_steer_index_at_with_reporter(base, new_files, reporter, &failures).await
}

/// Instrumented variant: emits separate `steer_sync` and `bm25_sync`
/// Phase events through the supplied reporter and records phase
/// failures into `failures` before propagating the error. Existing
/// callers reach this via the no-op shim above.
pub(super) async fn sync_steer_index_at_with_reporter(
    base: &Path,
    new_files: &[&PathBuf],
    reporter: Arc<dyn Reporter>,
    failures: &FailureLog,
) -> Result<()> {
    sync_steer_index_at_with_reporter_and_filter_base(base, base, new_files, reporter, failures)
        .await
}

pub(super) async fn sync_steer_index_at_with_reporter_and_filter_base(
    index_base: &Path,
    filter_base: &Path,
    new_files: &[&PathBuf],
    reporter: Arc<dyn Reporter>,
    failures: &FailureLog,
) -> Result<()> {
    let db_path = steer_db_path(index_base);
    let storage = StorageManager::new_lance_only(&db_path.to_string_lossy()).await?;
    storage.ensure_collection().await?;

    let (filtered_paths, _) = crate::store::filter_ignored_paths_at(filter_base, new_files)?;
    let filtered_refs: Vec<&PathBuf> = filtered_paths.iter().collect();
    let docs = build_steer_docs(&filtered_refs);

    if docs.is_empty() {
        return Ok(());
    }

    let total_docs = docs.len() as u64;

    let steer_phase = Phase::start(reporter.clone(), "steer_sync", Some(total_docs));
    let lance_result: Result<()> = async {
        let ids: Vec<&str> = docs.iter().map(|d| d.id.as_str()).collect();
        for id in ids {
            let _ = storage.delete_document(STEER_NAMESPACE, id).await;
        }

        let mut written: u64 = 0;
        for chunk in docs.chunks(1000) {
            storage.add_to_store(chunk.to_vec()).await?;
            written += chunk.len() as u64;
            steer_phase.tick(written);
        }
        Ok(())
    }
    .await;

    match lance_result {
        Ok(()) => {
            steer_phase.finish_ok(format!("{total_docs} docs"));
        }
        Err(e) => {
            let record = steer_phase.finish_err(&e, recovery_hint_for("steer_sync"));
            failures.record(record);
            return Err(e);
        }
    }

    let bm25_phase = Phase::start(reporter.clone(), "bm25_sync", Some(total_docs));
    match sync_steer_bm25_at(index_base, &docs).await {
        Ok(()) => {
            bm25_phase.finish_ok(format!("{total_docs} docs"));
        }
        Err(e) => {
            let record = bm25_phase.finish_err(&e, recovery_hint_for("bm25_sync"));
            failures.record(record);
            return Err(e);
        }
    }

    write_steer_metadata(index_base)?;
    Ok(())
}