use std::collections::HashMap;
use anyhow::Result;
use chrono::{DateTime, Utc};
use uuid::Uuid;
use crate::machine::MachineIdentity;
use crate::schema::{
CompactStats, Conversation, Entity, Memory, MemoryType, Relation, RelationType, SyncEntry,
SyncOp, SyncRecord, SyncState,
};
pub trait Store: Send + Sync {
fn store_memory(&self, memory: &Memory) -> Result<()>;
fn get_memory(&self, id: Uuid) -> Result<Option<Memory>>;
fn get_memory_with_embedding(&self, id: Uuid) -> Result<Option<Memory>>;
fn delete_memory(&self, id: Uuid) -> Result<()>;
fn remove_memory(&self, id: Uuid) -> Result<bool> {
let existed = self.get_memory(id)?.is_some();
self.delete_memory(id)?;
Ok(existed)
}
fn store_entity(&self, entity: &Entity) -> Result<()>;
fn get_entity(&self, id: Uuid) -> Result<Option<Entity>>;
fn find_entity_by_name(&self, name: &str) -> Result<Option<Entity>>;
fn store_conversation(&self, conversation: &Conversation) -> Result<()>;
fn store_relation(&self, relation: &Relation) -> Result<()>;
fn get_relations(
&self,
node_id: Uuid,
relation_type: Option<RelationType>,
) -> Result<Vec<Relation>>;
fn vector_search(&self, embedding: &[f32], limit: usize) -> Result<Vec<(Memory, f32)>>;
fn filtered_vector_search(
&self,
embedding: &[f32],
source: Option<&str>,
memory_type: Option<MemoryType>,
project_path: Option<&str>,
limit: usize,
) -> Result<Vec<(Memory, f32)>>;
fn traverse(&self, start_id: Uuid, depth: u32) -> Result<Vec<(Memory, Vec<Relation>)>>;
fn memories_by_source(&self, source: &str) -> Result<Vec<Memory>>;
fn memories_by_type(&self, memory_type: MemoryType) -> Result<Vec<Memory>>;
fn source_admits(&self, memory: &Memory, source: &str) -> Result<bool> {
Ok(memory.source == source)
}
fn chunk_window(&self, memory_id: Uuid, ord: usize) -> Result<Option<String>> {
let _ = (memory_id, ord);
Ok(None)
}
fn update_memory(&self, memory: &Memory) -> Result<()>;
fn record_access(&self, memory: &Memory) -> Result<()>;
fn record_accesses(&self, ids: &[Uuid]) -> Result<()> {
let now = Utc::now();
for id in ids {
if let Some(mut memory) = self.get_memory(*id)? {
memory.access_count += 1;
memory.last_accessed = now;
self.record_access(&memory)?;
}
}
Ok(())
}
fn bm25_search(&self, query: &str, limit: usize) -> Result<Vec<Memory>>;
fn memory_count(&self) -> Result<usize>;
fn all_memory_ids(&self) -> Result<Vec<Uuid>>;
fn all_relations(&self) -> Result<Vec<Relation>>;
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ConsolidationStats {
pub distilled_live: u64,
pub raw_pending: u64,
pub raw_retired: u64,
pub raw_retire_pending: u64,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ExplicitRestoreStats {
pub raws_restored: u64,
pub markers_dropped: u64,
pub distillates_superseded: u64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct StraySlugReport {
pub memories_refiled: u64,
pub refiled: Vec<RefiledSlug>,
pub ambiguous: Vec<AmbiguousSlug>,
pub unresolved: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct RefiledSlug {
pub from: String,
pub to: String,
pub memories: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct AmbiguousSlug {
pub slug: String,
pub candidates: Vec<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ApplyOutcome {
Created,
Updated,
Deleted,
Skipped(SkipReason),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SkipReason {
AlreadyPresent,
Tombstoned,
DanglingEndpoint,
StaleWrite,
Unsupported,
}
impl SkipReason {
pub fn as_str(self) -> &'static str {
match self {
SkipReason::AlreadyPresent => "already_present",
SkipReason::Tombstoned => "tombstoned",
SkipReason::DanglingEndpoint => "dangling_endpoint",
SkipReason::StaleWrite => "stale_write",
SkipReason::Unsupported => "unsupported",
}
}
}
pub trait StoreAdmin: Store {
fn register_machine(&self, identity: &MachineIdentity) -> Result<()>;
fn get_all_machines(&self) -> Result<HashMap<String, String>>;
fn diagnostic(&self) -> Result<String>;
fn find_or_create_entity(&self, name: &str, entity_type: &str) -> Result<Entity>;
fn memory_content_exists(&self, content_prefix: &str) -> Result<bool>;
fn is_file_changed(&self, file_path: &str, file_hash: &str) -> Result<bool>;
fn mark_ingested(
&self,
file_path: &str,
file_hash: &str,
memory_count: usize,
source: &str,
) -> Result<()>;
fn ingested_file_count(&self) -> Result<usize>;
fn clear_ingest_log(&self) -> Result<usize>;
fn delete_memories_by_source(&self, source: &str) -> Result<usize>;
fn delete_memories_by_source_id(&self, source_id: &str) -> Result<usize>;
fn rebuild_vector_index(&self) -> Result<()>;
fn backfill_project_paths(&self) -> Result<u64>;
fn backfill_sync_log(&self) -> Result<u64>;
fn backfill_tombstones(&self) -> Result<u64>;
fn prune_dangling_relations(&self) -> Result<u64>;
fn compact_sync_log(&self, ops: &[SyncOp], dry_run: bool) -> Result<CompactStats>;
fn memories_by_project_path(&self, project_path: &str) -> Result<Vec<Memory>>;
fn distinct_project_paths(&self) -> Result<Vec<(String, u64)>>;
fn all_memories_with_embeddings(&self) -> Result<Vec<Memory>>;
fn consolidation_stats(&self) -> Result<ConsolidationStats>;
fn unconsolidated_memories(&self, limit: usize) -> Result<Vec<Memory>>;
fn mark_consolidated(&self, raw_id: Uuid, distilled_id: Uuid, model: &str) -> Result<()>;
fn retire_consolidated_raws(&self) -> Result<usize>;
fn memories_created_between(
&self,
start: &DateTime<Utc>,
end: &DateTime<Utc>,
) -> Result<Vec<Memory>>;
fn sync_log_since(&self, after_seq: u64) -> Result<Vec<SyncEntry>>;
fn sync_log_page(&self, after_seq: u64, limit: Option<usize>) -> Result<Vec<SyncEntry>>;
fn max_sync_seq(&self) -> Result<u64>;
fn get_sync_state(&self, peer_id: &str) -> Result<Option<SyncState>>;
fn set_sync_state(&self, state: &SyncState) -> Result<()>;
fn get_all_sync_states(&self) -> Result<Vec<SyncState>>;
fn tombstone_exists(&self, id: Uuid) -> Result<bool>;
fn apply_record(&self, record: &SyncRecord) -> Result<ApplyOutcome>;
fn apply_batch(&self, records: &[SyncRecord]) -> Result<Vec<ApplyOutcome>>;
}