Struct RagSync 

pub struct RagSync { /* private fields */ }

Bundles a vault, its dirty-set, and the server client, and drives sync. The caller (the TUI) owns the schedule: probe to gate features, and call tick periodically to keep the server in step.

Implementations

impl RagSync

pub fn new(vault: Arc<NoteVault>, client: RagClient) -> Self

Registers the observer on vault and returns a handle over it. Construct one RagSync per vault: the observer is zero-or-one, so a second RagSync for the same vault replaces the first’s observer and strands its dirty-set (its tick still self-heals via reconcile, but its drain fast path goes silent).

pub async fn probe(&self) -> Option<ServerProbe>

Probe reachability, capability, and auth in one /health request: None = offline; otherwise a ServerProbe carrying the server’s ServerCapability — Unconfigured (no embedder: don’t sync), SemanticOnly (search, no Q&A), or Full — and whether the API requires a bearer token.

pub fn index_ready(&self) -> bool

Whether the local index is filled and safe to sync from. false while a healed/rebuilding index is still empty — syncing then would read “no notes” and tear the server collection down (see reconcile).

pub async fn tick(&self) -> Result<bool, RagError>

One sync pass: flush pending changes, then reconcile to repair drift. Returns false when either half was skipped because the local index is not ready yet — call again once it is.

pub async fn drain(&self) -> Result<bool, RagError>

Flush pending changes only — the cheap fast path (touches only dirty notes). Run this often; run tick/reconcile occasionally as the safety net. Returns false when skipped because the local index is not ready.

pub async fn reconcile(&self) -> Result<bool, RagError>

Full hash-diff reconciliation only — an index-wide read + a full-collection hash fetch. The periodic backbone; not needed on every tick. Returns false when skipped because the local index is not ready.

pub fn client(&self) -> &RagClient

The underlying client, for queries (search / ask).

Trait Implementations

impl Drop for RagSync

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.