use serde::{Deserialize, Deserializer};
use serde_json::Value;
use uuid::Uuid;
pub use khive_brain_core::SectionType;
#[derive(Debug, Clone)]
pub(crate) struct Section {
pub id: uuid::Uuid,
pub atom_id: String,
pub namespace: String,
pub section_type: SectionType,
pub heading: String,
pub content: String,
pub content_hash: String,
pub status: String,
pub tokens: i64,
pub sort_order: i64,
pub created_at: i64,
pub updated_at: i64,
}
#[derive(Debug, Clone)]
pub(crate) struct Atom {
pub id: Uuid,
pub namespace: String,
pub slug: String,
pub name: String,
pub content: String,
pub tags: String,
pub properties: Option<String>,
pub status: Option<String>,
pub source_uri: Option<String>,
pub source_type: Option<String>,
pub finalized: bool,
pub created_at: i64,
pub updated_at: i64,
#[allow(dead_code)]
pub deleted_at: Option<i64>,
}
impl Atom {
pub fn tags_display(&self) -> String {
let v: Vec<String> = serde_json::from_str(&self.tags).unwrap_or_default();
v.join(" ")
}
}
#[derive(Debug, Clone)]
pub(crate) struct Domain {
pub id: Uuid,
pub namespace: String,
pub slug: String,
pub name: String,
pub description: Option<String>,
pub tags: String,
pub members: String,
pub created_at: i64,
pub updated_at: i64,
#[allow(dead_code)]
pub deleted_at: Option<i64>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct AtomInput {
pub slug: String,
pub name: String,
#[serde(default)]
pub content: Option<String>,
#[serde(default)]
pub tags: Option<Vec<String>>,
#[serde(default)]
pub properties: Option<Value>,
#[serde(default, deserialize_with = "tri_state")]
pub finalized: Option<Option<bool>>,
#[serde(default, deserialize_with = "tri_state")]
pub source_uri: Option<Option<String>>,
#[serde(default, deserialize_with = "tri_state")]
pub source_type: Option<Option<String>>,
}
fn tri_state<'de, T, D>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
where
T: Deserialize<'de>,
D: Deserializer<'de>,
{
Ok(Some(Option::deserialize(deserializer)?))
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct UpsertAtomsParams {
pub atoms: Vec<AtomWrite>,
#[serde(default)]
pub dry_run: bool,
#[serde(default)]
pub chunk_size: Option<usize>,
}
#[derive(Debug)]
pub(crate) enum AtomWrite {
Upsert(AtomInput),
PropertiesOnly(AtomPropertiesInput),
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct AtomPropertiesInput {
pub id: Uuid,
#[serde(deserialize_with = "Value::deserialize")]
pub properties: Value,
}
impl<'de> Deserialize<'de> for AtomWrite {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = Value::deserialize(deserializer)?;
if value.get("id").is_some() {
serde_json::from_value(value)
.map(Self::PropertiesOnly)
.map_err(serde::de::Error::custom)
} else {
serde_json::from_value(value)
.map(Self::Upsert)
.map_err(serde::de::Error::custom)
}
}
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct DomainInput {
pub slug: String,
pub name: String,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub tags: Option<Vec<String>>,
#[serde(default)]
pub members: Option<Vec<String>>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct UpsertDomainsParams {
pub domains: Vec<DomainInput>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct GetParams {
pub id: String,
#[serde(default)]
pub include_sections: Option<bool>,
}
#[derive(Debug, Deserialize, Default)]
#[serde(deny_unknown_fields)]
pub(crate) struct ListParams {
#[serde(rename = "type", alias = "kind", default)]
pub kind: Option<String>,
#[serde(default)]
pub limit: Option<usize>,
#[serde(default)]
pub offset: Option<usize>,
#[serde(default)]
pub after: Option<String>,
#[serde(default)]
pub fields: Option<Vec<String>>,
#[serde(default)]
pub status: Option<Value>,
#[serde(default)]
pub exclude_status: Option<String>,
}
#[derive(Debug, Deserialize, Default)]
#[serde(deny_unknown_fields)]
pub(crate) struct StatsParams {}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct DeleteAtomsParams {
pub ids: Vec<String>,
#[serde(default)]
pub cascade: Option<bool>,
}
#[derive(Debug, Deserialize, Default)]
#[serde(deny_unknown_fields)]
pub(crate) struct IndexParams {
#[serde(default)]
pub ids: Option<Vec<String>>,
#[serde(default)]
pub batch_size: Option<usize>,
#[serde(default)]
pub insert_only: Option<bool>,
#[serde(default)]
pub rebuild_ann: Option<bool>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct FoldParams {
pub candidates: Vec<FoldCandidate>,
pub budget: usize,
#[serde(default)]
pub min_score: Option<f32>,
#[serde(default)]
pub category_weights: Option<std::collections::BTreeMap<String, f32>>,
#[serde(default)]
pub diversity_bias: Option<f32>,
#[serde(default)]
pub epistemic_weight: Option<f32>,
}
#[derive(Debug, Clone, Deserialize, serde::Serialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct FoldCandidate {
pub id: String,
pub score: f32,
pub size: usize,
#[serde(default)]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub members: Option<usize>,
#[serde(default)]
pub content: Option<Value>,
#[serde(default)]
pub category: Option<String>,
#[serde(default)]
pub information_gain: Option<f32>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct SearchParams {
pub query: String,
#[serde(rename = "type", alias = "kind", default)]
pub kind: Option<String>,
#[serde(default)]
pub status: Option<Value>,
#[serde(default)]
pub exclude_status: Option<String>,
#[serde(default)]
pub include_drafts: Option<bool>,
#[serde(default)]
pub role: Option<String>,
#[serde(default)]
pub limit: Option<usize>,
#[serde(default)]
pub min_score: Option<f64>,
#[serde(default)]
pub weights: Option<SearchWeights>,
#[serde(default)]
pub decompose: Option<bool>,
#[serde(default)]
pub decompose_threshold: Option<usize>,
#[serde(default)]
pub intersection_bonus: Option<f64>,
#[serde(default)]
pub rerank: Option<bool>,
#[serde(default)]
pub rerank_alpha: Option<f64>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct SearchWeights {
pub w_exact_name: Option<f64>,
pub w_name: Option<f64>,
pub w_tags: Option<f64>,
pub w_content: Option<f64>,
pub expand_discount: Option<f64>,
pub coverage_alpha: Option<f64>,
pub w_bigram: Option<f64>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct SuggestParams {
pub query: String,
#[serde(default)]
pub role: Option<String>,
#[serde(default)]
pub limit: Option<usize>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct ComposeParams {
#[serde(default)]
pub namespace: Option<String>,
#[serde(default)]
pub domain_ids: Option<Vec<String>>,
#[serde(default)]
pub atom_ids: Option<Vec<String>>,
pub query: String,
#[serde(default)]
pub auto_limit: Option<usize>,
#[serde(default)]
pub max_tokens: Option<usize>,
#[serde(default)]
pub explain: Option<bool>,
#[serde(default)]
pub blend_kg: Option<bool>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct SectionUpdate {
pub section_type: String,
pub content: String,
#[serde(default)]
pub heading: Option<String>,
#[serde(default)]
pub sort_order: Option<i64>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct EditParams {
pub id: String,
pub sections: Vec<SectionUpdate>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct ChallengeParams {
pub atom_id: String,
pub section_type: String,
#[serde(default)]
pub content_hash: Option<String>,
#[serde(default)]
pub reason: Option<String>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct AdjudicateParams {
pub atom_id: String,
pub section_type: String,
#[serde(default)]
pub content_hash: Option<String>,
pub resolution: String,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct ImportParams {
pub path: String,
#[serde(default)]
pub format: Option<String>,
#[serde(default)]
pub chunk_strategy: Option<String>,
}